From ec430efcc6a5e768b865a7e210c617d9f9e16804 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 14 Jan 2021 14:43:09 +0100
Subject: [PATCH 01/56] operations: vget

---
 src/include/multi_array_operation.cc.h | 64 +++++++++++++++++++++++++-
 src/include/multi_array_operation.h    | 34 ++++++++++++++
 src/include/pack_num.h                 | 21 +++++++++
 3 files changed, 118 insertions(+), 1 deletion(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 6096506..d1684de 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -222,7 +222,7 @@ namespace MultiArrayTools
     {
 	return RootSumN<sizeof...(Ops)-1>::get(last,mOps);
     }
-    
+
     template <typename T, class... Ops>
     inline MOp<T,Ops...>& MOp<T,Ops...>::set(ExtType last)
     {
@@ -390,6 +390,13 @@ namespace MultiArrayTools
 	return mDataPtr[pos.val()/*+mOff*/];
     }
 
+    template <typename T, class... Ranges>
+    template <typename V, class ET>
+    inline const V& ConstOperationRoot<T,Ranges...>::vget(ET pos) const
+    {
+	return *reinterpret_cast<const V*>(mDataPtr+pos.val());
+    }
+
     template <typename T, class... Ranges>
     template <class ET>
     inline ConstOperationRoot<T,Ranges...>& ConstOperationRoot<T,Ranges...>::set(ET pos)
@@ -437,6 +444,14 @@ namespace MultiArrayTools
 	return static_cast<T>( mOp.get(pos) );
     }
 
+    template <typename T, class Op>
+    template <typename V, class ET>
+    inline V StaticCast<T,Op>::vget(ET pos) const
+    {
+	assert(0); // !!!
+	return V();
+    }
+
     template <typename T, class Op>
     template <class ET>
     inline StaticCast<T,Op>& StaticCast<T,Op>::set(ET pos)
@@ -481,6 +496,15 @@ namespace MultiArrayTools
 	return (mWorkIndex = pos.val()).meta();
     }
 
+    template <class Range>
+    template <typename V, class ET>
+    inline V
+    MetaOperationRoot<Range>::vget(ET pos) const
+    {
+	assert(0); // !!!
+	return V();
+    }
+
     template <class Range>
     template <class ET>
     inline MetaOperationRoot<Range>& MetaOperationRoot<Range>::set(ET pos)
@@ -633,6 +657,13 @@ namespace MultiArrayTools
 	return mDataPtr[pos.val()];
     }
 
+    template <typename T, class... Ranges>
+    template <typename V, class ET>
+    inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
+    {
+	return *reinterpret_cast<V*>(mDataPtr + pos.val());
+    }
+
     template <typename T, class... Ranges>
     template <class ET>
     inline OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::set(ET pos)
@@ -773,6 +804,13 @@ namespace MultiArrayTools
 	return mDataPtr[pos.val()/*+mOff*/];
     }
 
+    template <typename T, class... Ranges>
+    template <typename V, class ET>
+    inline V& ParallelOperationRoot<T,Ranges...>::vget(ET pos) const
+    {
+	return *reinterpret_cast<V*>(mDataPtr+pos.val());
+    }
+
     template <typename T, class... Ranges>
     template <class ET>
     inline ParallelOperationRoot<T,Ranges...>& ParallelOperationRoot<T,Ranges...>::set(ET pos)
@@ -818,6 +856,13 @@ namespace MultiArrayTools
 	return mVal;
     }
 
+    template <typename T>
+    template <typename V, class ET>
+    inline V OperationValue<T>::vget(ET pos) const
+    {
+	return static_cast<V>(mVal); // implement???!!!
+    }
+
     template <typename T>
     template <class ET>
     inline OperationValue<T>& OperationValue<T>::set(ET pos)
@@ -868,6 +913,15 @@ namespace MultiArrayTools
 	    template mkOpExpr<SIZE,ET,OpTuple,OpFunction>(mF, pos, mOps);
     }
 
+    template <typename T, class OpFunction, class... Ops>
+    template <typename V, class ET>
+    inline auto Operation<T,OpFunction,Ops...>::vget(ET pos) const
+    {
+	typedef std::tuple<Ops...> OpTuple;
+	return PackNum<sizeof...(Ops)-1>::
+	    template mkVOpExpr<SIZE,V,ET,OpTuple,OpFunction>(mF, pos, mOps); // implement!!!
+    }
+
     template <typename T, class OpFunction, class... Ops>
     template <class ET>
     inline Operation<T,OpFunction,Ops...>& Operation<T,OpFunction,Ops...>::set(ET pos)
@@ -911,6 +965,14 @@ namespace MultiArrayTools
 	return mOp.template get<ET>(pos);
     }
 
+    template <typename T, class Op, class IndexType>
+    template <typename V, class ET>
+    inline auto Contraction<T,Op,IndexType>::vget(ET pos) const
+        -> decltype(mOp.template vget<V,ET>(pos))
+    {
+	return mOp.template vget<V,ET>(pos);
+    }
+
     template <typename T, class Op, class IndexType>
     template <class ET>
     inline Contraction<T,Op,IndexType>& Contraction<T,Op,IndexType>::set(ET pos)
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 871db03..280c1cc 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -203,6 +203,7 @@ namespace MultiArrayTools
                            EXTERN = 0,
                            TARGET = 1
     };
+
     
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr2 : public ExpressionBase
@@ -261,6 +262,10 @@ namespace MultiArrayTools
 	MOp& operator=(MOp&& in) = default;
 
         inline size_t get(ExtType last) const;
+
+	template <typename V>
+	inline size_t vget(ExtType last) const { return get(last); }
+	
 	inline MOp& set(ExtType last);
         auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
 
@@ -301,6 +306,10 @@ namespace MultiArrayTools
 
         inline void operator()(size_t start = 0);
         inline void get(ExtType last);
+
+	template <typename V>
+        inline void vget(ExtType last) { get(last); }
+	
         inline void operator()(size_t start, ExtType last);
         auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
 
@@ -388,6 +397,9 @@ namespace MultiArrayTools
 	template <class ET>
 	inline const T& get(ET pos) const;
 
+	template <typename V, class ET>
+	inline const V& vget(ET pos) const;
+	
 	template <class ET>
 	inline ConstOperationRoot& set(ET pos);
 
@@ -427,6 +439,9 @@ namespace MultiArrayTools
 	template <class ET>
 	inline T get(ET pos) const;
 
+	template <typename V, class ET>
+	inline V vget(ET pos) const;
+
 	template <class ET>
 	inline StaticCast& set(ET pos);
 
@@ -462,6 +477,9 @@ namespace MultiArrayTools
 	template <class ET>
 	inline value_type get(ET pos) const;
 
+	template <typename V, class ET>
+	inline V vget(ET pos) const;
+
 	template <class ET>
 	inline MetaOperationRoot& set(ET pos);
 
@@ -541,6 +559,9 @@ namespace MultiArrayTools
 	template <class ET>
 	inline T& get(ET pos) const;
 
+	template <typename V, class ET>
+	inline V& vget(ET pos) const;
+	
 	template <class ET>
 	inline OperationRoot& set(ET pos);
 
@@ -612,6 +633,9 @@ namespace MultiArrayTools
         
 	template <class ET>
 	inline T& get(ET pos) const;
+	 
+	template <typename V, class ET>
+	inline V& vget(ET pos) const;
 
 	template <class ET>
 	inline ParallelOperationRoot& set(ET pos);
@@ -642,6 +666,9 @@ namespace MultiArrayTools
 	template <class ET>
 	inline const T& get(ET pos) const;
 
+	template <typename V, class ET>
+	inline V vget(ET pos) const;
+
 	template <class ET>
 	inline OperationValue& set(ET pos);
 
@@ -682,6 +709,9 @@ namespace MultiArrayTools
 	template <class ET>
 	inline auto get(ET pos) const;
 
+	template <typename V, class ET>
+	inline auto vget(ET pos) const;
+
 	template <class ET>
 	inline Operation& set(ET pos);
 
@@ -754,6 +784,10 @@ namespace MultiArrayTools
 	inline auto get(ET pos) const
             -> decltype(mOp.template get<ET>(pos));
 
+	template <typename V, class ET>
+	inline auto vget(ET pos) const
+            -> decltype(mOp.template vget<V,ET>(pos));
+
 	template <class ET>
 	inline Contraction& set(ET pos);
 
diff --git a/src/include/pack_num.h b/src/include/pack_num.h
index 5a185c5..7b6af61 100644
--- a/src/include/pack_num.h
+++ b/src/include/pack_num.h
@@ -81,6 +81,17 @@ namespace MultiArrayHelper
 		( f, pos, ops, std::get<N>(ops).get(Getter<NEXT>::template getX<ETuple>( pos )), args...);
 	}
 
+	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
+	static inline auto mkVOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, Args... args)
+	{
+	    typedef typename std::remove_reference<decltype(std::get<N>(ops))>::type NextOpType;
+	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
+	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
+	    typedef decltype(std::get<N>(ops).template vget<V>(Getter<NEXT>::template getX<ETuple>( pos ))) ArgT;
+	    return PackNum<N-1>::template mkVOpExpr<NEXT,ETuple,OpTuple,OpFunction,ArgT,Args...>
+		( f, pos, ops, std::get<N>(ops).template vget<V>(Getter<NEXT>::template getX<ETuple>( pos )), args...);
+	}
+
 	template <class OpTuple, class Expr>
 	static auto mkLoop( const OpTuple& ot, Expr exp )
 	    -> decltype(std::get<N>(ot).loop( PackNum<N-1>::mkLoop(ot,exp) ))
@@ -168,6 +179,16 @@ namespace MultiArrayHelper
 	    //return OpFunction::apply(std::get<0>(ops).get(Getter<0>::template getX<ETuple>( pos )), args...);
 	}
 
+	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
+	static inline auto mkVOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, const Args&... args)
+	{
+	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
+	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
+	    static_assert(NEXT == 0, "inconsistent array positions");
+	    typedef decltype(std::get<0>(ops).template vget<V>(Getter<0>::template getX<ETuple>( pos ))) ArgT;
+	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).template vget<V>(Getter<0>::template getX<ETuple>( pos )), args...);
+	}
+
 	template <class OpTuple, class Expr>
 	static auto mkLoop( const OpTuple& ot, Expr exp )
 	    -> decltype(std::get<0>(ot).loop( exp ))

From 6ecbe5ff27502383a604dffb7870de41884bdabe Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 14 Jan 2021 16:26:53 +0100
Subject: [PATCH 02/56] minor changes

---
 src/include/multi_array_operation.cc.h | 17 +++++++----
 src/include/multi_array_operation.h    | 39 ++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 5 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index d1684de..f0d9c32 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -174,15 +174,18 @@ namespace MultiArrayTools
     {
         ExtType last = rootSteps();
 	last.zero();
-        mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
-        //mDataPtr[last.val()] = mSec.get(last.next());
+        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
+	IAssign::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
+
+	//mDataPtr[last.val()] = mSec.get(last.next());
     }
 
     template <typename T, class Target, class OpClass, OpIndexAff OIA>
     inline void AssignmentExpr2<T,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
         //CHECK;
-        mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
+        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
+	IAssign::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
     }
     
     template <typename T, class Target, class OpClass, OpIndexAff OIA>
@@ -303,7 +306,9 @@ namespace MultiArrayTools
     template <typename T, class Target, class OpClass, OpIndexAff OIA>
     inline void AddExpr<T,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
-        mDataPtr[OpIndexResolve<OIA>::get(start,last)] += mSec.get(last.next());
+	//IPlus::f(mDataPtr[OpIndexResolve<OIA>::get(start,last)],mSec.get(last.next()));
+	IPlus::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
+        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] += mSec.get(last.next());
         //mDataPtr[start] += mSec.get(last.next());
         //mDataPtr[start] += mSec.template get<ExtType>(last);
     }
@@ -313,7 +318,9 @@ namespace MultiArrayTools
     {
         ExtType last = rootSteps();
 	last.zero();
-        mDataPtr[OpIndexResolve<OIA>::get(start,last)] += mSec.get(last.next());
+        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] += mSec.get(last.next());
+	//IPlus::f(mDataPtr[OpIndexResolve<OIA>::get(start,last)],mSec.get(last.next()));
+	IPlus::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
     }
     
     template <typename T, class Target, class OpClass, OpIndexAff OIA>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 280c1cc..742fb72 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -204,6 +204,45 @@ namespace MultiArrayTools
                            TARGET = 1
     };
 
+    struct IAssign
+    {
+	template <typename T, typename Op, class ExtType>
+	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
+	{
+	    //a = b;
+	    t[pos] = op.get(e);
+	}
+    };
+
+    template <typename V>
+    struct IVAssign
+    {
+	template <typename T1, typename T2>
+	static inline void f(T1& a, const T2& b)
+	{
+	    *reinterpret_cast<V*>(&a) = b;
+	}
+    };
+
+    struct IPlus
+    {
+	template <typename T, typename Op, class ExtType>
+	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
+	{
+	    t[pos] += op.get(e);
+	}
+    };
+
+    template <typename V>
+    struct IVPlus
+    {
+	template <typename T1, typename T2>
+	static inline void f(T1& a, const T2& b)
+	{
+	    *reinterpret_cast<V*>(&a) += b;
+	}
+    };
+
     
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr2 : public ExpressionBase

From fdb1bb6833d569b5fe1dfc2da2ca154043d0b5fe Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 14 Jan 2021 17:40:08 +0100
Subject: [PATCH 03/56] xfor: vectrization requirements

---
 src/include/map_range.cc.h             | 23 +++++++++++++++++++++++
 src/include/map_range.h                | 10 ++++++++--
 src/include/multi_array_operation.cc.h |  6 +++---
 src/include/xfor/xfor.h                | 20 ++++++++++++++++++++
 4 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 678b32e..8f786dd 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -27,6 +27,18 @@ namespace MultiArrayTools
         assert(mIndPtr != nullptr);
     }
 
+    template <class Op, class Index, class Expr, SpaceType STYPE>
+    std::shared_ptr<ExpressionBase> OpExpr<Op,Index,Expr,STYPE>::deepCopy() const
+    {
+	return std::make_shared<OpExpr<Op,Index,Expr,STYPE>>(*this);
+    }
+    
+    template <class Op, class Index, class Expr, SpaceType STYPE>
+    inline void OpExpr<Op,Index,Expr,STYPE>::operator()(size_t mlast, DExt last)
+    {
+	operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
+    }
+
     template <class Op, class Index, class Expr, SpaceType STYPE>
     inline void OpExpr<Op,Index,Expr,STYPE>::operator()(size_t mlast,
                                                             ExtType last)
@@ -63,7 +75,18 @@ namespace MultiArrayTools
 	//return mExpr.rootSteps(iPtrNum).extend( mOp.rootSteps(iPtrNum) );
     }
 
+    template <class Op, class Index, class Expr, SpaceType STYPE>
+    DExt OpExpr<Op,Index,Expr,STYPE>::dRootSteps(std::intptr_t iPtrNum) const
+    {
+	return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
+    }
     
+    template <class Op, class Index, class Expr, SpaceType STYPE>
+    DExt OpExpr<Op,Index,Expr,STYPE>::dExtension() const
+    {
+	return std::make_shared<ExtT<ExtType>>(mExt);
+    }
+
     // -> define in range_base.cc
     //std::shared_ptr<RangeFactoryBase> mkMULTI(const char** dp);
     
diff --git a/src/include/map_range.h b/src/include/map_range.h
index fcb56f3..42623b0 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -50,7 +50,7 @@ namespace MultiArrayTools
     
     template <class Op, class Index, class Expr, SpaceType STYPE = SpaceType::ANY>
     //template <class MapF, class IndexPack, class Expr, SpaceType STYPE = SpaceType::ANY>
-    class OpExpr
+    class OpExpr : public ExpressionBase
     {
     public:
         //typedef typename Index::OIType OIType;
@@ -80,11 +80,17 @@ namespace MultiArrayTools
 
         OpExpr(const Op& mapf, const Index* ind, size_t step, Expr ex);
 
+	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final;
+	
+	inline void operator()(size_t mlast, DExt last) override final;
 	inline void operator()(size_t mlast, ExtType last);
-	inline void operator()(size_t mlast = 0);
+	inline void operator()(size_t mlast = 0) override final;
 
 	auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
 
+	virtual DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
+	virtual DExt dExtension() const override final;
+	
     };
     
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index f0d9c32..70dbf7e 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -401,7 +401,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline const V& ConstOperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	return *reinterpret_cast<const V*>(mDataPtr+pos.val());
+	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
     }
 
     template <typename T, class... Ranges>
@@ -668,7 +668,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	return *reinterpret_cast<V*>(mDataPtr + pos.val());
+	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
     }
 
     template <typename T, class... Ranges>
@@ -815,7 +815,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& ParallelOperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	return *reinterpret_cast<V*>(mDataPtr+pos.val());
+	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 58a8106..292b666 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -173,6 +173,8 @@ namespace MultiArrayHelper
 	ExpressionBase& operator=(const ExpressionBase& in) = default;
 	ExpressionBase& operator=(ExpressionBase&& in) = default;
 
+	virtual std::intptr_t vec(size_t vs) { return 0; }
+	
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const = 0;
 	
 	virtual void operator()(size_t mlast, DExt last) = 0;
@@ -377,6 +379,15 @@ namespace MultiArrayHelper
 	    return std::make_shared<For<IndexClass,Expr,FT>>(*this);
 	}
 
+	virtual std::intptr_t vec(size_t vs) override final
+	{
+	    if(mStep == 1 and mMax % vs == 0){
+		mMax /= vs;
+		return reinterpret_cast<std::intptr_t>(mIndPtr);
+	    }
+	    return mExpr.vec(vs);
+	}
+
 	inline void operator()(size_t mlast, DExt last) override final;
 	inline void operator()(size_t mlast, ExtType last) ;
 	inline void operator()(size_t mlast = 0) override final;
@@ -425,6 +436,15 @@ namespace MultiArrayHelper
 	PFor(const IndexClass* indPtr,
 	    size_t step, Expr expr);
 
+	virtual std::intptr_t vec(size_t vs) override final
+	{
+	    if(mStep == 1 and mMax % vs == 0){
+		mMax /= vs;
+		return reinterpret_cast<std::intptr_t>(mIndPtr);
+	    }
+	    return mExpr.vec(vs);
+	}
+
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
 	{
 	    return std::make_shared<PFor<IndexClass,Expr>>(*this);

From 29b1502e60d1e0473180b55e8d96845019e65680 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 14 Jan 2021 19:20:46 +0100
Subject: [PATCH 04/56] unify AssigmentExpr2 and AddExpr

---
 src/include/multi_array_operation.cc.h | 38 +++++++++++++-------------
 src/include/multi_array_operation.h    | 27 +++++++++++-------
 src/include/xfor/exttype.h             | 36 ++++++++++++++++++++++--
 3 files changed, 69 insertions(+), 32 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 70dbf7e..9c88d37 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -165,50 +165,50 @@ namespace MultiArrayTools
     };
 
     
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    AssignmentExpr2<T,Target,OpClass,OIA>::AssignmentExpr2(T* dataPtr, const Target& tar, const OpClass& sec) :
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    AssignmentExpr<T,IOp,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
         mTar(tar), mSec(sec), mDataPtr(dataPtr) {}
     
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr2<T,Target,OpClass,OIA>::operator()(size_t start)
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t start)
     {
         ExtType last = rootSteps();
 	last.zero();
         //mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
-	IAssign::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
+	IOp::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
 
 	//mDataPtr[last.val()] = mSec.get(last.next());
     }
 
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr2<T,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
         //CHECK;
         //mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
-	IAssign::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
+	IOp::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
     }
     
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    typename AssignmentExpr2<T,Target,OpClass,OIA>::ExtType
-    AssignmentExpr2<T,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    typename AssignmentExpr<T,IOp,Target,OpClass,OIA>::ExtType
+    AssignmentExpr<T,IOp,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
     {
 	return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
     }
 
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr2<T,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
     {
         (*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
     }
 
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr2<T,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,IOp,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
     {
         return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
     }
 
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr2<T,Target,OpClass,OIA>::dExtension() const
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,IOp,Target,OpClass,OIA>::dExtension() const
     {
         CHECK;
         return nullptr; //???!!!
@@ -298,7 +298,7 @@ namespace MultiArrayTools
         CHECK;
         return nullptr; //???!!!
     }
-
+    /*
     template <typename T, class Target, class OpClass, OpIndexAff OIA>
     AddExpr<T,Target,OpClass,OIA>::AddExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
         mTar(tar), mSec(sec), mDataPtr(dataPtr) {}
@@ -348,7 +348,7 @@ namespace MultiArrayTools
         CHECK;
         return nullptr; //???!!!
     }
-
+    */
     /****************************
      *   ConstOperationRoot     *
      ****************************/
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 742fb72..b8ac7e8 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -244,11 +244,11 @@ namespace MultiArrayTools
     };
 
     
-    template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    class AssignmentExpr2 : public ExpressionBase
+    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
+    class AssignmentExpr : public ExpressionBase
     {
     private:
-        AssignmentExpr2() = default;
+        AssignmentExpr() = default;
 
         Target mTar;
         OpClass mSec;
@@ -260,15 +260,15 @@ namespace MultiArrayTools
         static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
         typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
 	    
-        AssignmentExpr2(T* dataPtr, const Target& tar, const OpClass& sec);
-        AssignmentExpr2(const AssignmentExpr2& in) = default;
-        AssignmentExpr2(AssignmentExpr2&& in) = default;
-        AssignmentExpr2& operator=(const AssignmentExpr2& in) = default;
-        AssignmentExpr2& operator=(AssignmentExpr2&& in) = default;
+        AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec);
+        AssignmentExpr(const AssignmentExpr& in) = default;
+        AssignmentExpr(AssignmentExpr&& in) = default;
+        AssignmentExpr& operator=(const AssignmentExpr& in) = default;
+        AssignmentExpr& operator=(AssignmentExpr&& in) = default;
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
 	{
-	    return std::make_shared<AssignmentExpr2<T,Target,OpClass,OIA>>(*this);
+	    return std::make_shared<AssignmentExpr<T,IOp,Target,OpClass,OIA>>(*this);
 	}
 	
         inline void operator()(size_t start = 0); 
@@ -281,6 +281,12 @@ namespace MultiArrayTools
         inline DExt dExtension() const override final;
     };
 
+    template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
+    using AssignmentExpr2 = AssignmentExpr<T,IAssign,Target,OpClass,OIA>;
+
+    template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
+    using AddExpr = AssignmentExpr<T,IPlus,Target,OpClass,OIA>;
+
     template <typename T, class... Ops>
     class MOp
     {
@@ -371,6 +377,7 @@ namespace MultiArrayTools
     }
 
     //template <typename T, class OpClass>
+    /*
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AddExpr : public ExpressionBase
     {
@@ -411,7 +418,7 @@ namespace MultiArrayTools
         inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
         inline DExt dExtension() const override final;
     };
-
+    */
     template <typename T, class... Ranges>
     class ConstOperationRoot : public OperationTemplate<T,ConstOperationRoot<T,Ranges...> >
     {
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index 9f94784..b6202c4 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -85,7 +85,17 @@ namespace MultiArrayHelper
         inline auto nn() const
             -> decltype(Getter<N>::getX(*this))
         { return Getter<N>::getX(*this); }
-        
+
+	inline bool operator==(const MExt& in) const
+	{
+	    return mExt == in.mExt and mNext == in.mNext;
+	}
+
+	inline bool operator==(size_t in) const
+	{
+	    return mExt == in and mNext == in;
+	}
+
 	inline MExt operator+(const MExt& in) const;
 	inline MExt operator+(const None& in) const;
 	inline MExt operator*(size_t in) const;
@@ -110,7 +120,17 @@ namespace MultiArrayHelper
         None(const Y& y) {}
         
         static constexpr size_t SIZE = 0;
-        
+
+	inline bool operator==(const None& in) const
+	{
+	    return true;
+	}
+
+	inline bool operator==(size_t in) const
+	{
+	    return true; // CHECK!!!
+	}
+
         inline None operator+(const None& in) const { return None(); }
 	inline None operator*(size_t in) const { return None(); }
 
@@ -157,7 +177,17 @@ namespace MultiArrayHelper
 
         template <class Y>
         inline MExt(const MExt<Y>& y);
-        
+
+	inline bool operator==(const MExt& in) const
+	{
+	    return mExt == in.mExt;
+	}
+
+	inline bool operator==(size_t in) const
+	{
+	    return mExt == in;
+	}
+
 	inline const size_t& val() const;
 	inline None next() const { return None(); }
 

From 68ae7d84287179c7118842b838db34a08eed2edd Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 14 Jan 2021 23:57:06 +0100
Subject: [PATCH 05/56] im com

---
 src/include/multi_array_operation.cc.h | 55 --------------------
 src/include/multi_array_operation.h    | 70 ++++++++------------------
 2 files changed, 20 insertions(+), 105 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 9c88d37..b849726 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -174,17 +174,12 @@ namespace MultiArrayTools
     {
         ExtType last = rootSteps();
 	last.zero();
-        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
 	IOp::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
-
-	//mDataPtr[last.val()] = mSec.get(last.next());
     }
 
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
     inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
-        //CHECK;
-        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
 	IOp::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
     }
     
@@ -298,57 +293,7 @@ namespace MultiArrayTools
         CHECK;
         return nullptr; //???!!!
     }
-    /*
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    AddExpr<T,Target,OpClass,OIA>::AddExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
-        mTar(tar), mSec(sec), mDataPtr(dataPtr) {}
-    
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline void AddExpr<T,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
-    {
-	//IPlus::f(mDataPtr[OpIndexResolve<OIA>::get(start,last)],mSec.get(last.next()));
-	IPlus::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
-        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] += mSec.get(last.next());
-        //mDataPtr[start] += mSec.get(last.next());
-        //mDataPtr[start] += mSec.template get<ExtType>(last);
-    }
 
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline void AddExpr<T,Target,OpClass,OIA>::operator()(size_t start)
-    {
-        ExtType last = rootSteps();
-	last.zero();
-        //mDataPtr[OpIndexResolve<OIA>::get(start,last)] += mSec.get(last.next());
-	//IPlus::f(mDataPtr[OpIndexResolve<OIA>::get(start,last)],mSec.get(last.next()));
-	IPlus::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
-    }
-    
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    typename AddExpr<T,Target,OpClass,OIA>::ExtType AddExpr<T,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
-    {
-	return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
-	//return mSec.rootSteps(iPtrNum);
-    }
-
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline void AddExpr<T,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
-    {
-        (*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
-    }
-
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AddExpr<T,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
-    {
-        return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
-    }
-
-    template <typename T, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AddExpr<T,Target,OpClass,OIA>::dExtension() const
-    {
-        CHECK;
-        return nullptr; //???!!!
-    }
-    */
     /****************************
      *   ConstOperationRoot     *
      ****************************/
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index b8ac7e8..2d3787d 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -16,8 +16,8 @@
 #include "pack_num.h"
 
 #include "arith.h"
-
 #include "xfor/xfor.h"
+#include "type_operations.h"
 
 namespace MultiArrayTools
 {
@@ -217,10 +217,10 @@ namespace MultiArrayTools
     template <typename V>
     struct IVAssign
     {
-	template <typename T1, typename T2>
-	static inline void f(T1& a, const T2& b)
+	template <typename T, typename Op, class ExtType>
+	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
-	    *reinterpret_cast<V*>(&a) = b;
+	    reinterpret_cast<V*>(t)[pos] = op.template vget<V>(e);
 	}
     };
 
@@ -236,13 +236,26 @@ namespace MultiArrayTools
     template <typename V>
     struct IVPlus
     {
-	template <typename T1, typename T2>
-	static inline void f(T1& a, const T2& b)
+	template <typename T, typename Op, class ExtType>
+	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
-	    *reinterpret_cast<V*>(&a) += b;
+	    reinterpret_cast<V*>(t)[pos] += op.template vget<V>(e);
 	}
     };
 
+    template <class T>
+    struct VType
+    {
+	typedef T type;
+	static constexpr size_t MULT = sizeof(type)/sizeof(T);
+    };
+
+    template <>
+    struct VType<double>
+    {
+	typedef v256 type;
+	static constexpr size_t MULT = sizeof(type)/sizeof(double);
+    };
     
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
@@ -376,49 +389,6 @@ namespace MultiArrayTools
         return MOp<T,Ops...>(exprs...);
     }
 
-    //template <typename T, class OpClass>
-    /*
-    template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    class AddExpr : public ExpressionBase
-    {
-    private:
-        AddExpr() = default;
-	    	    
-        Target mTar;
-        OpClass mSec;
-        T* mDataPtr;
-            
-    public:
-
-        static constexpr size_t LAYER = 0;
-        static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
-        typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
-        //        static constexpr size_t LAYER = 0;
-        //static constexpr size_t SIZE = OpClass::SIZE;
-        //typedef decltype(mSec.rootSteps()) ExtType;
-	    
-        //AddExpr(T* dataPtr, const OpClass& sec);
-        AddExpr(T* dataPtr, const Target& tar, const OpClass& sec);
-        AddExpr(const AddExpr& in) = default;
-        AddExpr(AddExpr&& in) = default;
-        AddExpr& operator=(const AddExpr& in) = default;
-        AddExpr& operator=(AddExpr&& in) = default;
-	    
-	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
-	{
-	    return std::make_shared<AddExpr<T,Target,OpClass,OIA>>(*this);
-	}
-
-        inline void operator()(size_t start = 0); 
-        inline void operator()(size_t start, ExtType last);
-        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
-
-        inline void operator()(size_t mlast, DExt last) override final;
-
-        inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
-        inline DExt dExtension() const override final;
-    };
-    */
     template <typename T, class... Ranges>
     class ConstOperationRoot : public OperationTemplate<T,ConstOperationRoot<T,Ranges...> >
     {

From db9219704835e976958a161e9f9f1b5e83dc73d3 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 15 Jan 2021 01:05:58 +0100
Subject: [PATCH 06/56] im com (Operation: remove T?)

---
 src/include/multi_array_operation.cc.h | 77 +++++++++++++++++---------
 src/include/multi_array_operation.h    | 36 +++++++-----
 src/include/pack_num.h                 |  2 +-
 src/include/xfor/xfor.h                | 14 +++++
 4 files changed, 89 insertions(+), 40 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index b849726..b9d0207 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -519,66 +519,91 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Ranges>
-    template <class OpClass>
-    auto OperationRoot<T,Ranges...>::assign(const OpClass& in) const
-        -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+    template <class IOp, class OpClass>
+    auto OperationRoot<T,Ranges...>::asx(const OpClass& in) const
+        -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
                                           (mOrigDataPtr,*this,in))))
 
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return mIndex.ifor(1,in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+        return mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
                                      (mOrigDataPtr,*this,in)));
     }
 
+    template <typename T, class... Ranges>
+    template <class IOp, class OpClass>
+    auto OperationRoot<T,Ranges...>::asxExpr(const OpClass& in) const
+        -> decltype(in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
+                            (mOrigDataPtr,*this,in)))
+    {
+        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
+        return in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
+                       (mOrigDataPtr,*this,in));
+    }
+    
+    template <typename T, class... Ranges>
+    template <class IOp, class OpClass, class Index>
+    auto OperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
+        -> decltype(i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
+                                      (mOrigDataPtr,*this,in))))
+    {
+        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
+        return i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
+                                 (mOrigDataPtr,*this,in)));
+    }
+
+    template <typename T, class... Ranges>
+    template <class OpClass>
+    auto OperationRoot<T,Ranges...>::assign(const OpClass& in) const
+        -> decltype(this->template asx<IAssign>(in))
+    {
+        return this->template asx<IAssign>(in);
+    }
+
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assignExpr(const OpClass& in) const
-        -> decltype(in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass>
-                            (mOrigDataPtr,*this,in)))
+        -> decltype(this->template asxExpr<IAssign>(in))
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass>
-                       (mOrigDataPtr,*this,in));
+        return this->template asxExpr<IAssign>(in);
     }
     
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(i->ifor(1,in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass>
-                                      (mOrigDataPtr,*this,in))))
+        -> decltype(this->template asx<IAssign>(in,i))
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->ifor(1,in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,*this,in)));
+        return this->template asx<IAssign>(in,i);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in) const
-        -> decltype(mIndex.ifor(1,in.loop(AddExpr<T,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                          (mOrigDataPtr,*this,in))))
+        -> decltype(this->template asx<IPlus>(in))
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return mIndex.ifor(1,in.loop(AddExpr<T,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mOrigDataPtr,*this,in)));
+        return this->template asx<IPlus>(in);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(i->ifor(1,in.loop(AddExpr<T,OperationRoot<T,Ranges...>,OpClass>
-                                      (mOrigDataPtr,*this,in))))
+        -> decltype(this->template asx<IPlus>(in,i))
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->ifor(1,in.loop(AddExpr<T,OperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,*this,in)));
+        return this->template asx<IPlus>(in,i);
     }
     
     template <typename T, class... Ranges>
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-        assign(in)();
+        auto x = this->template asx<IVAssign<typename VType<T>::type>>(in);
+	const size_t inum = x.vec(VType<T>::MULT);
+	if(x.rootSteps(inum) == 1){
+	    x();
+	}
+	else {
+	    assign(in)();
+	}
         return *this;
     }
 
@@ -613,7 +638,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
+	return *(reinterpret_cast<V*>(mDataPtr)+pos.val());
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 2d3787d..53e284b 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -538,29 +538,39 @@ namespace MultiArrayTools
 
 	OperationRoot(T* data, const IndexType& ind);
 
-        template <class OpClass>
-        auto assign(const OpClass& in) const
-            -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+        template <class IOp, class OpClass>
+        auto asx(const OpClass& in) const
+            -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
                                               (mOrigDataPtr,*this,in))));
 
-        template <class OpClass>
-        auto assignExpr(const OpClass& in) const
-            -> decltype(in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass>(mOrigDataPtr,*this,in)));
+        template <class IOp, class OpClass>
+        auto asxExpr(const OpClass& in) const
+            -> decltype(in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>(mOrigDataPtr,*this,in)));
             
-        template <class OpClass, class Index>
-        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-            -> decltype(i->ifor(1,in.loop(AssignmentExpr2<T,OperationRoot<T,Ranges...>,OpClass>
+        template <class IOp, class OpClass, class Index>
+        auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const
+            -> decltype(i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
                                           (mOrigDataPtr,*this,in))));
             
         template <class OpClass>
+        auto assign(const OpClass& in) const
+	    -> decltype(this->template asx<IAssign>(in));
+
+	template <class OpClass>
+        auto assignExpr(const OpClass& in) const
+	    -> decltype(this->template asxExpr<IAssign>(in));
+	    
+        template <class OpClass, class Index>
+        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
+	    -> decltype(this->template asx<IAssign>(in,i));
+	
+	template <class OpClass>
         auto plus(const OpClass& in) const
-            -> decltype(mIndex.ifor(1,in.loop(AddExpr<T,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                              (mOrigDataPtr,*this,in))));
+	    -> decltype(this->template asx<IPlus>(in));
 
         template <class OpClass, class Index>
         auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-            -> decltype(i->ifor(1,in.loop(AddExpr<T,OperationRoot<T,Ranges...>,OpClass>
-                                          (mOrigDataPtr,*this,in))));
+	    -> decltype(this->template asx<IPlus>(in,i));
             
         template <class OpClass>
         OperationRoot& operator=(const OpClass& in);
diff --git a/src/include/pack_num.h b/src/include/pack_num.h
index 7b6af61..234e6bf 100644
--- a/src/include/pack_num.h
+++ b/src/include/pack_num.h
@@ -88,7 +88,7 @@ namespace MultiArrayHelper
 	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
 	    typedef decltype(std::get<N>(ops).template vget<V>(Getter<NEXT>::template getX<ETuple>( pos ))) ArgT;
-	    return PackNum<N-1>::template mkVOpExpr<NEXT,ETuple,OpTuple,OpFunction,ArgT,Args...>
+	    return PackNum<N-1>::template mkVOpExpr<NEXT,V,ETuple,OpTuple,OpFunction,ArgT,Args...>
 		( f, pos, ops, std::get<N>(ops).template vget<V>(Getter<NEXT>::template getX<ETuple>( pos )), args...);
 	}
 
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 292b666..1ee58f5 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -35,6 +35,9 @@ namespace MultiArrayHelper
 	virtual size_t size() const = 0;
 	virtual const size_t& val() const = 0;
 	//virtual size_t rootSteps() const = 0;
+	virtual bool operator==(const ExtBase& in) const = 0;
+	virtual bool operator==(size_t in) const = 0;
+	    
 	virtual std::shared_ptr<ExtBase> operator+(const ExtBase& in) const = 0;
 	virtual std::shared_ptr<ExtBase> operator*(size_t in) const = 0;
 	virtual void zero() = 0;
@@ -75,6 +78,12 @@ namespace MultiArrayHelper
 	virtual const size_t& val() const override final { return mExt.val(); }
 	virtual void zero() override final { mExt.zero(); }
 
+	virtual bool operator==(const ExtBase& in) const override final
+	{ return mExt == dynamic_cast<const ExtT<ExtType>&>(in).mExt; }
+	
+	virtual bool operator==(size_t in) const override final
+	{ return mExt == in; }
+
 	virtual DExt operator+(const ExtBase& in) const override final
 	{ return std::make_shared<ExtT<ExtType>>( mExt + dynamic_cast<const ExtT<ExtType>&>(in).mExt ); }
 	virtual DExt operator*(size_t in) const override final
@@ -122,6 +131,11 @@ namespace MultiArrayHelper
 	template <class Y>
 	DExtTX(const Y& y) : mDExt(std::make_shared<ExtT<Y>>(y)) {}
         */
+	bool operator==(const DExtTX& in) const
+	{ return *mDExt == *in.mDExt and mNext == in.mNext; }
+	
+	bool operator==(size_t in) const
+	{ return *mDExt == in and mNext == in; }
 
         template <class Y>
         DExtTX(const DExtTX<Y>& in) : mDExt(in.mDExt), mNext(in.mNext) {}

From 64d10867dd251b4fca90a6eda0d526ef6c3b9d0e Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Mon, 18 Jan 2021 19:00:12 +0100
Subject: [PATCH 07/56] finish parts of auto-vectorization

---
 src/include/arith.h                    |   8 +-
 src/include/dynamic_operation.h        |   7 ++
 src/include/multi_array_operation.cc.h |  63 ++++++++-----
 src/include/multi_array_operation.h    | 117 ++++++++++++++++++++-----
 src/include/type_operations.h          |  31 ++++++-
 5 files changed, 180 insertions(+), 46 deletions(-)

diff --git a/src/include/arith.h b/src/include/arith.h
index db34d75..e9339d8 100644
--- a/src/include/arith.h
+++ b/src/include/arith.h
@@ -48,7 +48,8 @@ namespace MultiArrayTools
     {
 	static constexpr bool FISSTATIC = true;
 	typedef T value_type;
-	
+	typedef F function;
+
 	template <class... Ops>
 	static auto mk(const Ops&... ops)
 	    -> Operation<T,F,Ops...>
@@ -74,6 +75,11 @@ namespace MultiArrayTools
 	{
 	    return a;
 	}
+
+	static inline T selfApply(T& a1, const T& a2)
+	{
+	    return a1 = a2;
+	}
     };
 
     template <typename T, typename U>
diff --git a/src/include/dynamic_operation.h b/src/include/dynamic_operation.h
index 12c1936..3835019 100644
--- a/src/include/dynamic_operation.h
+++ b/src/include/dynamic_operation.h
@@ -17,6 +17,7 @@ namespace MultiArrayTools
 	
 	static constexpr size_t SIZE = 1;
 	static constexpr bool CONT = true;
+	static constexpr bool VABLE = false;
 	
 	DynamicOperationBase() = default;
 	DynamicOperationBase(const DynamicOperationBase& in) = default;
@@ -125,6 +126,7 @@ namespace MultiArrayTools
 	
 	static constexpr size_t SIZE = 1;
 	static constexpr bool CONT = true;
+	static constexpr bool VABLE = false;
 	
 	DynamicO() = default;
 	DynamicO(const DynamicO& in) : mOp(in.mOp ? in.mOp->deepCopy() : nullptr) {}
@@ -144,6 +146,11 @@ namespace MultiArrayTools
 	
         template <class X>
 	inline T get(const DExtTX<X>& pos) const { return mOp->get(pos.reduce()); }
+
+	template <typename V,class X>
+	inline auto vget(const DExtTX<X>& pos) const
+	{ return mOp->template vget<V>(pos.reduce()); }
+	
         template <class X>
 	inline DynamicO& set(const DExtTX<X>& pos) { mOp->set(pos.reduce()); return *this; }
 	inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return mOp->rootSteps(iPtrNum); }
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index b9d0207..0f1fa41 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -555,55 +555,78 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in) const
-        -> decltype(this->template asx<IAssign>(in))
+        -> decltype(this->template asx<IAssign<T>>(in))
     {
-        return this->template asx<IAssign>(in);
+        return this->template asx<IAssign<T>>(in);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assignExpr(const OpClass& in) const
-        -> decltype(this->template asxExpr<IAssign>(in))
+        -> decltype(this->template asxExpr<IAssign<T>>(in))
     {
-        return this->template asxExpr<IAssign>(in);
+        return this->template asxExpr<IAssign<T>>(in);
     }
     
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(this->template asx<IAssign>(in,i))
+        -> decltype(this->template asx<IAssign<T>>(in,i))
     {
-        return this->template asx<IAssign>(in,i);
+        return this->template asx<IAssign<T>>(in,i);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in) const
-        -> decltype(this->template asx<IPlus>(in))
+        -> decltype(this->template asx<IPlus<T>>(in))
     {
-        return this->template asx<IPlus>(in);
+        return this->template asx<IPlus<T>>(in);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(this->template asx<IPlus>(in,i))
+        -> decltype(this->template asx<IPlus<T>>(in,i))
     {
-        return this->template asx<IPlus>(in,i);
+        return this->template asx<IPlus<T>>(in,i);
     }
-    
+
+    template <bool VABLE = false>
+    struct VExec
+    {
+	template <typename TarOp, class OpClass>
+	static inline void exec(TarOp& th, const OpClass& in)
+	{
+	    th.assign(in)();
+	}
+    };
+
+    template <>
+    struct VExec<true>
+    {
+	template <typename TarOp, class OpClass>
+	static inline void exec(TarOp& th, const OpClass& in)
+	{
+	    CHECK;
+	    typedef typename TarOp::value_type T;
+	    auto x = th.template asx<IVAssign<typename VType<T>::type,T>>(in);
+	    const size_t inum = x.vec(VType<T>::MULT);
+	    if(x.rootSteps(inum) == 1){
+		CHECK;
+		x();
+	    }
+	    else {
+		th.assign(in)();
+	    }
+	}
+    };
+
     template <typename T, class... Ranges>
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-        auto x = this->template asx<IVAssign<typename VType<T>::type>>(in);
-	const size_t inum = x.vec(VType<T>::MULT);
-	if(x.rootSteps(inum) == 1){
-	    x();
-	}
-	else {
-	    assign(in)();
-	}
+	VExec<OpClass::VABLE>::exec(*this,in);
         return *this;
     }
 
@@ -896,7 +919,7 @@ namespace MultiArrayTools
     {
 	typedef std::tuple<Ops...> OpTuple;
 	return PackNum<sizeof...(Ops)-1>::
-	    template mkVOpExpr<SIZE,V,ET,OpTuple,OpFunction>(mF, pos, mOps); // implement!!!
+	    template mkVOpExpr<SIZE,V,ET,OpTuple,VFunc<OpFunction>>(mkVFuncPtr(mF), pos, mOps); // implement!!!
     }
 
     template <typename T, class OpFunction, class... Ops>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 53e284b..bc35d0e 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -204,12 +204,74 @@ namespace MultiArrayTools
                            TARGET = 1
     };
 
+    template <class T>
+    struct VType
+    {
+	typedef T type;
+	static constexpr size_t MULT = sizeof(type)/sizeof(T);
+    };
+
+    template <>
+    struct VType<double>
+    {
+	typedef v256 type;
+	static constexpr size_t MULT = sizeof(type)/sizeof(double);
+    };
+
+    template <template <typename...> class F,typename... Ts>
+    inline auto mkVFuncPtr(const std::shared_ptr<F<Ts...>>& f)
+    {
+	return std::shared_ptr<F<typename VType<Ts>::type...>>();
+	// empty, implement corresponding constructors...!!!
+    }
+
+    template <template <typename...> class F,typename... Ts>
+    inline auto mkVFunc(const F<Ts...>& f)
+    {
+	return F<typename VType<Ts>::type...>();
+	// empty, implement corresponding constructors...!!!
+    }
+
+    template <class F>
+    using VFunc = decltype(mkVFunc(std::declval<F>()));
+
+    template <class F>
+    struct IAccess
+    {
+	template <typename T, typename Op, class ExtType>
+	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
+	{
+	    F::selfApply(t[pos],op.get(e));
+	}
+    };
+
+    template <typename V, class F>
+    struct IVAccess
+    {
+	template <typename T, typename Op, class ExtType>
+	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
+	{
+	    VFunc<F>::selfApply(reinterpret_cast<V*>(t)[pos],op.template vget<V>(e));
+	}
+    };
+
+    template <typename T>
+    using IAssign = IAccess<identity<T>>;
+
+    template <typename T>
+    using IPlus = IAccess<plus<T>>;
+
+    template <typename V, typename T>
+    using IVAssign = IVAccess<V,identity<T>>;
+
+    template <typename V, typename T>
+    using IVPlus = IVAccess<V,plus<T>>;
+    /*
     struct IAssign
     {
 	template <typename T, typename Op, class ExtType>
 	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
-	    //a = b;
 	    t[pos] = op.get(e);
 	}
     };
@@ -223,7 +285,7 @@ namespace MultiArrayTools
 	    reinterpret_cast<V*>(t)[pos] = op.template vget<V>(e);
 	}
     };
-
+    
     struct IPlus
     {
 	template <typename T, typename Op, class ExtType>
@@ -242,20 +304,8 @@ namespace MultiArrayTools
 	    reinterpret_cast<V*>(t)[pos] += op.template vget<V>(e);
 	}
     };
+    */
 
-    template <class T>
-    struct VType
-    {
-	typedef T type;
-	static constexpr size_t MULT = sizeof(type)/sizeof(T);
-    };
-
-    template <>
-    struct VType<double>
-    {
-	typedef v256 type;
-	static constexpr size_t MULT = sizeof(type)/sizeof(double);
-    };
     
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
@@ -295,10 +345,10 @@ namespace MultiArrayTools
     };
 
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    using AssignmentExpr2 = AssignmentExpr<T,IAssign,Target,OpClass,OIA>;
+    using AssignmentExpr2 = AssignmentExpr<T,IAssign<T>,Target,OpClass,OIA>;
 
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    using AddExpr = AssignmentExpr<T,IPlus,Target,OpClass,OIA>;
+    using AddExpr = AssignmentExpr<T,IPlus<T>,Target,OpClass,OIA>;
 
     template <typename T, class... Ops>
     class MOp
@@ -401,6 +451,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = true;
+        static constexpr bool VABLE = true;
 	
 	ConstOperationRoot(const MultiArrayBase<T,Ranges...>& ma,
 			   const std::shared_ptr<typename Ranges::IndexType>&... indices);
@@ -449,6 +500,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = Op::SIZE;
         static constexpr bool CONT = false;
+        static constexpr bool VABLE = false;
 	
 	StaticCast(const Op& op);
 
@@ -487,6 +539,7 @@ namespace MultiArrayTools
 	
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = false;
+        static constexpr bool VABLE = false;
         
 	MetaOperationRoot(const std::shared_ptr<IndexType>& ind);
 
@@ -522,6 +575,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = true;
+        static constexpr bool VABLE = true;
 
     private:
 
@@ -554,23 +608,23 @@ namespace MultiArrayTools
             
         template <class OpClass>
         auto assign(const OpClass& in) const
-	    -> decltype(this->template asx<IAssign>(in));
+	    -> decltype(this->template asx<IAssign<T>>(in));
 
 	template <class OpClass>
         auto assignExpr(const OpClass& in) const
-	    -> decltype(this->template asxExpr<IAssign>(in));
+	    -> decltype(this->template asxExpr<IAssign<T>>(in));
 	    
         template <class OpClass, class Index>
         auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-	    -> decltype(this->template asx<IAssign>(in,i));
+	    -> decltype(this->template asx<IAssign<T>>(in,i));
 	
 	template <class OpClass>
         auto plus(const OpClass& in) const
-	    -> decltype(this->template asx<IPlus>(in));
+	    -> decltype(this->template asx<IPlus<T>>(in));
 
         template <class OpClass, class Index>
         auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-	    -> decltype(this->template asx<IPlus>(in,i));
+	    -> decltype(this->template asx<IPlus<T>>(in,i));
             
         template <class OpClass>
         OperationRoot& operator=(const OpClass& in);
@@ -616,6 +670,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = true;
+        static constexpr bool VABLE = true;
 
     private:
 
@@ -686,6 +741,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = 0;
         static constexpr bool CONT = true;
+        static constexpr bool VABLE = false;
 
 	OperationValue(const T& val);
 
@@ -706,8 +762,18 @@ namespace MultiArrayTools
     private:
 	T mVal;
     };
-    
 
+    template <class Op> 
+    inline constexpr bool isVAble()
+    {
+	return Op::VABLE;
+    }
+
+    template <class Op1, class Op2, class... Ops>
+    inline constexpr bool isVAble()
+    {
+	return Op1::VABLE and isVAble<Op2,Ops...>();
+    }
     
     template <typename T, class OpFunction, class... Ops>
     class Operation : public OperationTemplate<T,Operation<T,OpFunction,Ops...> >
@@ -721,6 +787,7 @@ namespace MultiArrayTools
 	static constexpr size_t SIZE = RootSum<Ops...>::SIZE;
 	static constexpr bool FISSTATIC = OpFunction::FISSTATIC;
         static constexpr bool CONT = false;
+        static constexpr bool VABLE = isVAble<Ops...>();
 
     private:
 	std::tuple<Ops...> mOps;
@@ -795,6 +862,7 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = Op::SIZE;
         static constexpr bool CONT = Op::CONT;
+        static constexpr bool VABLE = Op::VABLE;
         
     private:
 
@@ -839,7 +907,8 @@ namespace MultiArrayTools
 
 	static constexpr size_t SIZE = Op::SIZE;
         static constexpr bool CONT = false;
-        
+	static constexpr bool VABLE = false;
+
     private:
 
 	mutable Op mOp;
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index cb6903b..7b438f2 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -10,6 +10,7 @@
 #include "mbase_def.h"
 
 #include "pack_num.h"
+#include <cmath>
 
 namespace MultiArrayTools
 {
@@ -470,7 +471,35 @@ namespace MultiArrayTools
         xsdiv<4>( o._x, a._x );
 	return o;
     }
-   
+
+    inline double xpow(const double& b, const double& e)
+    {
+	return pow(b,e);
+    }
+
+    inline v256 pow(const v256& b, const v256& e)
+    {
+	v256 out;
+	for(int i = 0; i < 4; i++){
+	    out._x[i] = xpow(b._x[i],e._x[i]);
+	}
+	return out;
+    }
+
+    inline double xexp(const double& a)
+    {
+	return exp(a);
+    }
+
+    inline v256 exp(const v256& a)
+    {
+	v256 out;
+	for(int i = 0; i < 4; i++){
+	    out._x[i] = xexp(a._x[i]);
+	}
+	return out;
+    }
+
 } // namespace MultiArrayTools
 
 #endif

From 15664781f7d87f776ff6565a967bdc56beb48a6a Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 21 Jan 2021 00:35:13 +0100
Subject: [PATCH 08/56] further auto vectorization (open issue: static loop
 reduction)

---
 src/include/multi_array_operation.cc.h | 91 ++++++++++++++++++--------
 src/include/multi_array_operation.h    | 42 ++++++++----
 src/include/xfor/xfor.h                |  8 ++-
 3 files changed, 100 insertions(+), 41 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 0f1fa41..2b554db 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -346,6 +346,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline const V& ConstOperationRoot<T,Ranges...>::vget(ET pos) const
     {
+	VCHECK(pos.val());
 	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
     }
 
@@ -595,29 +596,30 @@ namespace MultiArrayTools
     template <bool VABLE = false>
     struct VExec
     {
-	template <typename TarOp, class OpClass>
+	template <template <typename> class F, typename TarOp, class OpClass>
 	static inline void exec(TarOp& th, const OpClass& in)
 	{
-	    th.assign(in)();
+	    typedef typename TarOp::value_type T;
+	    th.template asx<IAccess<F<T>>>(in)();
 	}
     };
 
     template <>
     struct VExec<true>
     {
-	template <typename TarOp, class OpClass>
+	template <template <typename> class F, typename TarOp, class OpClass>
 	static inline void exec(TarOp& th, const OpClass& in)
 	{
 	    CHECK;
 	    typedef typename TarOp::value_type T;
-	    auto x = th.template asx<IVAssign<typename VType<T>::type,T>>(in);
+	    auto x = th.template asx<IVAccess<typename VType<T>::type,F<T>>>(in);
 	    const size_t inum = x.vec(VType<T>::MULT);
 	    if(x.rootSteps(inum) == 1){
 		CHECK;
 		x();
 	    }
 	    else {
-		th.assign(in)();
+		th.template asx<IAccess<F<T>>>(in)();
 	    }
 	}
     };
@@ -626,7 +628,7 @@ namespace MultiArrayTools
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-	VExec<OpClass::VABLE>::exec(*this,in);
+	VExec<OpClass::VABLE>::template exec<identity>(*this,in);
         return *this;
     }
 
@@ -634,7 +636,8 @@ namespace MultiArrayTools
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator+=(const OpClass& in)
     {
-        plus(in)();
+	VExec<OpClass::VABLE>::template exec<xxxplus>(*this,in);
+        //plus(in)();
         return *this;
     }
 
@@ -661,6 +664,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
+	VCHECK(pos.val());
 	return *(reinterpret_cast<V*>(mDataPtr)+pos.val());
     }
 
@@ -732,46 +736,77 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Ranges>
-    template <class OpClass>
-    auto ParallelOperationRoot<T,Ranges...>::assign(const OpClass& in)
-        -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr2<T,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+    template <class IOp, class OpClass>
+    auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in) const
+        -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
                                           (mOrigDataPtr,*this,in))))
 
     {
-        return mIndex.pifor(1,in.loop(AssignmentExpr2<T,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                      (mOrigDataPtr,*this,in)));
+        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
+        return mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+                                     (mOrigDataPtr,*this,in)));
     }
 
     template <typename T, class... Ranges>
-    template <class OpClass, class Index>
-    auto ParallelOperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(i->pifor(1,in.loop(AssignmentExpr2<T,ParallelOperationRoot<T,Ranges...>,OpClass>
-				       (mOrigDataPtr,*this,in))))
+    template <class IOp, class OpClass>
+    auto ParallelOperationRoot<T,Ranges...>::asxExpr(const OpClass& in) const
+        -> decltype(in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
+                            (mOrigDataPtr,*this,in)))
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->pifor(1,in.loop(AssignmentExpr2<T,ParallelOperationRoot<T,Ranges...>,OpClass>
-				  (mOrigDataPtr,*this,in)));
+        return in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
+                       (mOrigDataPtr,*this,in));
+    }
+    
+    template <typename T, class... Ranges>
+    template <class IOp, class OpClass, class Index>
+    auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
+        -> decltype(i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
+                                      (mOrigDataPtr,*this,in))))
+    {
+        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
+        return i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
+                                 (mOrigDataPtr,*this,in)));
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
-    auto ParallelOperationRoot<T,Ranges...>::plus(const OpClass& in)
-        -> decltype(mIndex.pifor(1,in.loop(AddExpr<T,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                           (mOrigDataPtr,*this,in))))
+    auto ParallelOperationRoot<T,Ranges...>::assign(const OpClass& in) const
+        -> decltype(this->template asx<IAssign<T>>(in))
     {
-        return mIndex.pifor(1,in.loop(AddExpr<T,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                      (mOrigDataPtr,*this,in)));
+        return this->template asx<IAssign<T>>(in);
+    }
+
+    template <typename T, class... Ranges>
+    template <class OpClass>
+    auto ParallelOperationRoot<T,Ranges...>::assignExpr(const OpClass& in) const
+        -> decltype(this->template asxExpr<IAssign<T>>(in))
+    {
+        return this->template asxExpr<IAssign<T>>(in);
+    }
+    
+    template <typename T, class... Ranges>
+    template <class OpClass, class Index>
+    auto ParallelOperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
+        -> decltype(this->template asx<IAssign<T>>(in,i))
+    {
+        return this->template asx<IAssign<T>>(in,i);
+    }
+
+    template <typename T, class... Ranges>
+    template <class OpClass>
+    auto ParallelOperationRoot<T,Ranges...>::plus(const OpClass& in) const
+        -> decltype(this->template asx<IPlus<T>>(in))
+    {
+        return this->template asx<IPlus<T>>(in);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto ParallelOperationRoot<T,Ranges...>::plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(i->pifor(1,in.loop(AddExpr<T,ParallelOperationRoot<T,Ranges...>,OpClass>
-				       (mOrigDataPtr,*this,in))))
+        -> decltype(this->template asx<IPlus<T>>(in,i))
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->pifor(1,in.loop(AddExpr<T,ParallelOperationRoot<T,Ranges...>,OpClass>
-				  (mOrigDataPtr,*this,in)));
+        return this->template asx<IPlus<T>>(in,i);
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index bc35d0e..dfbfcde 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -251,10 +251,14 @@ namespace MultiArrayTools
 	template <typename T, typename Op, class ExtType>
 	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
+	    VCHECK(pos);
 	    VFunc<F>::selfApply(reinterpret_cast<V*>(t)[pos],op.template vget<V>(e));
 	}
     };
 
+    template <typename T>
+    using xxxplus = plus<T>;
+    
     template <typename T>
     using IAssign = IAccess<identity<T>>;
 
@@ -684,25 +688,39 @@ namespace MultiArrayTools
 
 	ParallelOperationRoot(T* data, const IndexType& ind);
 
-        template <class OpClass>
-        auto assign(const OpClass& in)
-            -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr2<T,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                               (mOrigDataPtr,*this,in))));
+        template <class IOp, class OpClass>
+        auto asx(const OpClass& in) const
+            -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+                                              (mOrigDataPtr,*this,in))));
 
-        template <class OpClass, class Index>
-        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-            -> decltype(i->pifor(1,in.loop(AssignmentExpr2<T,ParallelOperationRoot<T,Ranges...>,OpClass>
+        template <class IOp, class OpClass>
+        auto asxExpr(const OpClass& in) const
+            -> decltype(in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>(mOrigDataPtr,*this,in)));
+            
+        template <class IOp, class OpClass, class Index>
+        auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const
+            -> decltype(i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
                                           (mOrigDataPtr,*this,in))));
+            
+        template <class OpClass>
+        auto assign(const OpClass& in) const
+	    -> decltype(this->template asx<IAssign<T>>(in));
 
 	template <class OpClass>
-        auto plus(const OpClass& in)
-            -> decltype(mIndex.pifor(1,in.loop(AddExpr<T,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                               (mOrigDataPtr,*this,in))));
+        auto assignExpr(const OpClass& in) const
+	    -> decltype(this->template asxExpr<IAssign<T>>(in));
+	    
+        template <class OpClass, class Index>
+        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
+	    -> decltype(this->template asx<IAssign<T>>(in,i));
+	
+	template <class OpClass>
+        auto plus(const OpClass& in) const
+	    -> decltype(this->template asx<IPlus<T>>(in));
 
         template <class OpClass, class Index>
         auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-            -> decltype(i->pifor(1,in.loop(AddExpr<T,ParallelOperationRoot<T,Ranges...>,OpClass>
-					   (mOrigDataPtr,*this,in))));
+	    -> decltype(this->template asx<IPlus<T>>(in,i));
 
         template <class OpClass>
         ParallelOperationRoot& operator=(const OpClass& in);
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 1ee58f5..4ba9041 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -396,7 +396,9 @@ namespace MultiArrayHelper
 	virtual std::intptr_t vec(size_t vs) override final
 	{
 	    if(mStep == 1 and mMax % vs == 0){
+		VCHECK(vs);
 		mMax /= vs;
+		VCHECK(mMax);
 		return reinterpret_cast<std::intptr_t>(mIndPtr);
 	    }
 	    return mExpr.vec(vs);
@@ -450,10 +452,14 @@ namespace MultiArrayHelper
 	PFor(const IndexClass* indPtr,
 	    size_t step, Expr expr);
 
-	virtual std::intptr_t vec(size_t vs) override final
+	template <size_t VS>
+	auto vec() const
 	{
+	    // statically distinguish!!!
 	    if(mStep == 1 and mMax % vs == 0){
+		VCHECK(vs);
 		mMax /= vs;
+		VCHECK(mMax);
 		return reinterpret_cast<std::intptr_t>(mIndPtr);
 	    }
 	    return mExpr.vec(vs);

From 3bacc6c1c416b753c78247f3f8b7352c6becb3b6 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sat, 23 Jan 2021 19:40:15 +0100
Subject: [PATCH 09/56] im com

---
 src/include/map_range.h                |   3 +
 src/include/multi_array_operation.cc.h |  18 +--
 src/include/multi_array_operation.h    |  34 ++--
 src/include/xfor/for_type.h            |   5 +-
 src/include/xfor/xfor.h                | 210 ++++++++++++++++---------
 5 files changed, 173 insertions(+), 97 deletions(-)

diff --git a/src/include/map_range.h b/src/include/map_range.h
index 42623b0..6831cc6 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -81,6 +81,9 @@ namespace MultiArrayTools
         OpExpr(const Op& mapf, const Index* ind, size_t step, Expr ex);
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final;
+
+	template <size_t VS>
+	inline auto vec() const { return *this; }
 	
 	inline void operator()(size_t mlast, DExt last) override final;
 	inline void operator()(size_t mlast, ExtType last);
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 2b554db..64fdecd 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -523,12 +523,12 @@ namespace MultiArrayTools
     template <class IOp, class OpClass>
     auto OperationRoot<T,Ranges...>::asx(const OpClass& in) const
         -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                          (mOrigDataPtr,*this,in))))
+                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
 
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mOrigDataPtr,*this,in)));
+                                     (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -546,11 +546,11 @@ namespace MultiArrayTools
     template <class IOp, class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
         -> decltype(i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                                      (mOrigDataPtr,*this,in))))
+                                      (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,*this,in)));
+                                 (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -600,7 +600,8 @@ namespace MultiArrayTools
 	static inline void exec(TarOp& th, const OpClass& in)
 	{
 	    typedef typename TarOp::value_type T;
-	    th.template asx<IAccess<F<T>>>(in)();
+	    IAccess<T,F<T>> tmp;
+	    th.template asx<decltype(tmp)>(in)();
 	}
     };
 
@@ -612,14 +613,13 @@ namespace MultiArrayTools
 	{
 	    CHECK;
 	    typedef typename TarOp::value_type T;
-	    auto x = th.template asx<IVAccess<typename VType<T>::type,F<T>>>(in);
-	    const size_t inum = x.vec(VType<T>::MULT);
-	    if(x.rootSteps(inum) == 1){
+	    auto x = th.template asx<IVAccess<T,F<T>>>(in);
+	    if(x.divResid() == 0){
 		CHECK;
 		x();
 	    }
 	    else {
-		th.template asx<IAccess<F<T>>>(in)();
+		th.template asx<IAccess<T,F<T>>>(in)();
 	    }
 	}
     };
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index dfbfcde..de33740 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -235,24 +235,32 @@ namespace MultiArrayTools
     template <class F>
     using VFunc = decltype(mkVFunc(std::declval<F>()));
 
-    template <class F>
+    template <typename T, class F>
     struct IAccess
     {
-	template <typename T, typename Op, class ExtType>
+	typedef T value_type;
+	typedef T in_type;
+	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
+
+	template <typename Op, class ExtType>
 	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
 	    F::selfApply(t[pos],op.get(e));
 	}
     };
 
-    template <typename V, class F>
+    template <typename T, class F>
     struct IVAccess
     {
-	template <typename T, typename Op, class ExtType>
+	typedef typename VType<T>::type value_type;
+	typedef T in_type;
+	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
+
+	template <typename Op, class ExtType>
 	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
 	    VCHECK(pos);
-	    VFunc<F>::selfApply(reinterpret_cast<V*>(t)[pos],op.template vget<V>(e));
+	    VFunc<F>::selfApply(reinterpret_cast<value_type*>(t)[pos],op.template vget<value_type>(e));
 	}
     };
 
@@ -260,16 +268,16 @@ namespace MultiArrayTools
     using xxxplus = plus<T>;
     
     template <typename T>
-    using IAssign = IAccess<identity<T>>;
+    using IAssign = IAccess<T,identity<T>>;
 
     template <typename T>
-    using IPlus = IAccess<plus<T>>;
+    using IPlus = IAccess<T,plus<T>>;
 
-    template <typename V, typename T>
-    using IVAssign = IVAccess<V,identity<T>>;
+    template <typename T>
+    using IVAssign = IVAccess<T,identity<T>>;
 
-    template <typename V, typename T>
-    using IVPlus = IVAccess<V,plus<T>>;
+    template <typename T>
+    using IVPlus = IVAccess<T,plus<T>>;
     /*
     struct IAssign
     {
@@ -599,7 +607,7 @@ namespace MultiArrayTools
         template <class IOp, class OpClass>
         auto asx(const OpClass& in) const
             -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                              (mOrigDataPtr,*this,in))));
+                                              (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
 
         template <class IOp, class OpClass>
         auto asxExpr(const OpClass& in) const
@@ -608,7 +616,7 @@ namespace MultiArrayTools
         template <class IOp, class OpClass, class Index>
         auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const
             -> decltype(i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                                          (mOrigDataPtr,*this,in))));
+                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
             
         template <class OpClass>
         auto assign(const OpClass& in) const
diff --git a/src/include/xfor/for_type.h b/src/include/xfor/for_type.h
index d6866a5..7ddaf18 100644
--- a/src/include/xfor/for_type.h
+++ b/src/include/xfor/for_type.h
@@ -10,9 +10,12 @@ namespace MultiArrayHelper
 	HIDDEN = 1	
     };
 
-    template <class IndexClass, class Expr, ForType FT = ForType::DEFAULT>
+    template <class IndexClass, class Expr, ForType FT = ForType::DEFAULT, size_t DIV = 1>
     class For;
 
+    template <class IndexClass, class Expr, size_t DIV = 1>
+    class PFor;
+
     
 } // end namespace MultiArrayHelper
 
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 4ba9041..c9f6584 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -187,8 +187,8 @@ namespace MultiArrayHelper
 	ExpressionBase& operator=(const ExpressionBase& in) = default;
 	ExpressionBase& operator=(ExpressionBase&& in) = default;
 
-	virtual std::intptr_t vec(size_t vs) { return 0; }
-	
+	virtual size_t divResid() const { return 0; }
+
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const = 0;
 	
 	virtual void operator()(size_t mlast, DExt last) = 0;
@@ -231,20 +231,20 @@ namespace MultiArrayHelper
     template <size_t ISSTATIC>
     struct ForBound
     {
-	template <size_t BOUND>
+	template <size_t BOUND, size_t DIV = 1>
 	static inline size_t bound(size_t bound)
 	{
-	    return bound;
+	    return bound / DIV;
 	}
     };
 
     template <>
     struct ForBound<1>
     {
-	template <size_t BOUND>
+	template <size_t BOUND, size_t DIV = 1>
 	static constexpr size_t bound(size_t bound)
 	{
-	    return BOUND;
+	    return BOUND / DIV;
 	}
     };
 
@@ -287,6 +287,9 @@ namespace MultiArrayHelper
 	    return std::make_shared<SingleExpression<IndexClass,Expr>>(*this);
 	}
 
+	template <size_t VS>
+	inline auto vec() const { return *this; }
+
 	inline void operator()(size_t mlast, DExt last) override final;
 	inline void operator()(size_t mlast, ExtType last);
 	inline void operator()(size_t mlast = 0) override final;
@@ -340,6 +343,9 @@ namespace MultiArrayHelper
 	    return std::make_shared<SubExpr<IndexClass,Expr>>(*this);
 	}
 
+	template <size_t VS>
+	inline auto vec() const { return *this; }
+
 	inline void operator()(size_t mlast, DExt last) override final;
 	inline void operator()(size_t mlast, ExtType last) ;
 	inline void operator()(size_t mlast = 0) override final;
@@ -351,15 +357,65 @@ namespace MultiArrayHelper
 	auto extension() const -> ExtType;
     };
 
-    template <class IndexClass, class Expr>
-    class PFor;
-    
-    template <class IndexClass, class Expr, ForType FT>
+    template <size_t LAYER, bool ISV>
+    struct MkVFor
+    {
+	template <size_t DIV, class IndexClass, class Expr>
+	using ptype = PFor<IndexClass,Expr,1>;
+
+	template <size_t DIV, class IndexClass, class Expr, ForType FT>
+	using type = For<IndexClass,Expr,FT,1>;
+    };
+
+    template <>
+    struct MkVFor<1,true>
+    {
+	template <size_t DIV, class IndexClass, class Expr>
+	using ptype = PFor<IndexClass,Expr,DIV>;
+
+	template <size_t DIV, class IndexClass, class Expr, ForType FT>
+	using type = For<IndexClass,Expr,FT,DIV>;
+    };
+
+    template <size_t LAYER>
+    struct MkVExpr
+    {
+	template <size_t VS, class Expr>
+	static auto mk(const Expr& e)
+	{
+	    return e.template vec<VS>();
+	}
+
+	template <class Expr>
+	static inline size_t divResid(const Expr& e)
+	{
+	    return e.divResid();
+	}
+    };
+
+    template <>
+    struct MkVExpr<1>
+    {
+	template <size_t VS, class Expr>
+	static auto mk(const Expr& e)
+	{
+	    return e; // terminate
+	}
+
+	template <class Expr>
+	static inline size_t divResid(const Expr& e)
+	{
+	    return 0;
+	}
+    };
+
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
     class For : public ExpressionBase
     {
     private:
 	For() = default;
 		
+	typedef typename IndexClass::RangeType RangeType;
 	const IndexClass* mIndPtr;
 	size_t mSPos;
 	size_t mMax;
@@ -376,6 +432,7 @@ namespace MultiArrayHelper
 	
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
+	static constexpr size_t MAX = RangeType::SIZE / DIV;
 
 	For(const For& in) = default;
 	For& operator=(const For& in) = default;
@@ -390,25 +447,24 @@ namespace MultiArrayHelper
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
 	{
-	    return std::make_shared<For<IndexClass,Expr,FT>>(*this);
+	    return std::make_shared<For<IndexClass,Expr,FT,DIV>>(*this);
 	}
 
-	virtual std::intptr_t vec(size_t vs) override final
+	virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
+
+	template <size_t VS>
+	auto vec() const
 	{
-	    if(mStep == 1 and mMax % vs == 0){
-		VCHECK(vs);
-		mMax /= vs;
-		VCHECK(mMax);
-		return reinterpret_cast<std::intptr_t>(mIndPtr);
-	    }
-	    return mExpr.vec(vs);
+	    typedef typename MkVFor<LAYER,RangeType::SIZE % DIV == 0 or RangeType::SIZE == static_cast<size_t>(-1)>::
+		template type<VS,IndexClass,decltype(MkVExpr<LAYER>::template mk<VS>(mExpr)),FT> oType;
+	    return oType(mIndPtr,mStep,MkVExpr<LAYER>::template mk<VS>(mExpr));
 	}
 
 	inline void operator()(size_t mlast, DExt last) override final;
 	inline void operator()(size_t mlast, ExtType last) ;
 	inline void operator()(size_t mlast = 0) override final;
 
-        PFor<IndexClass,Expr> parallel() const;
+        PFor<IndexClass,Expr,DIV> parallel() const;
         
         DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
         DExt dExtension() const override final;
@@ -418,12 +474,14 @@ namespace MultiArrayHelper
 
     };
 
-    template <class IndexClass, class Expr>
+   
+    template <class IndexClass, class Expr, size_t DIV>
     class PFor : public ExpressionBase
     {
     private:
 	PFor() = default;
 		
+	typedef typename IndexClass::RangeType RangeType;
 	const IndexClass* mIndPtr;
 	size_t mSPos;
 	size_t mMax;
@@ -440,29 +498,27 @@ namespace MultiArrayHelper
 	
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
+	static constexpr size_t MAX = RangeType::SIZE / DIV;
 
 	PFor(const PFor& in) = default;
 	PFor& operator=(const PFor& in) = default;
 	PFor(PFor&& in) = default;
 	PFor& operator=(PFor&& in) = default;
-       
+
 	PFor(const std::shared_ptr<IndexClass>& indPtr,
 	    size_t step, Expr expr);
 
 	PFor(const IndexClass* indPtr,
 	    size_t step, Expr expr);
 
+	virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
+
 	template <size_t VS>
 	auto vec() const
 	{
-	    // statically distinguish!!!
-	    if(mStep == 1 and mMax % vs == 0){
-		VCHECK(vs);
-		mMax /= vs;
-		VCHECK(mMax);
-		return reinterpret_cast<std::intptr_t>(mIndPtr);
-	    }
-	    return mExpr.vec(vs);
+	    typedef typename MkVFor<LAYER,RangeType::SIZE % DIV == 0 or RangeType::SIZE == static_cast<size_t>(-1)>::
+		template ptype<VS,IndexClass,decltype(MkVExpr<LAYER>::template mk<VS>(mExpr))> oType;
+	    return oType(mIndPtr,mStep,MkVExpr<LAYER>::template mk<VS>(mExpr));
 	}
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
@@ -542,6 +598,9 @@ namespace MultiArrayHelper
 	    return std::make_shared<DynamicExpression>(*this);
 	}
 
+	template <size_t VS>
+	inline auto vec() const { return *this; }
+
 	inline void operator()(size_t mlast, DExt last) override final;
         inline void operator()(size_t mlast, DExtT last) { (*this)(mlast,last.get()); }
 	inline void operator()(size_t mlast = 0) override final;
@@ -617,50 +676,52 @@ namespace MultiArrayHelper
      *     F o r     *
      *****************/
     
-    template <class IndexClass, class Expr, ForType FT>
-    For<IndexClass,Expr,FT>::For(const std::shared_ptr<IndexClass>& indPtr,
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    For<IndexClass,Expr,FT,DIV>::For(const std::shared_ptr<IndexClass>& indPtr,
 				 size_t step, Expr expr) :
 	mIndPtr(indPtr.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
         mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
     {
+	assert(mMax % DIV == 0);
 	assert(mIndPtr != nullptr);
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    For<IndexClass,Expr,FT>::For(const IndexClass* indPtr,
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    For<IndexClass,Expr,FT,DIV>::For(const IndexClass* indPtr,
 				 size_t step, Expr expr) :
 	mIndPtr(indPtr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
         mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
     {
+	assert(mMax % DIV == 0);
 	assert(mIndPtr != nullptr);
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    inline void For<IndexClass,Expr,FT>::operator()(size_t mlast, DExt last)
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    inline void For<IndexClass,Expr,FT,DIV>::operator()(size_t mlast, DExt last)
     {
         operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
         //operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
     }
     
-    template <class IndexClass, class Expr, ForType FT>
-    inline void For<IndexClass,Expr,FT>::operator()(size_t mlast,
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    inline void For<IndexClass,Expr,FT,DIV>::operator()(size_t mlast,
 						    ExtType last)
     {
 	typedef typename IndexClass::RangeType RangeType;
-	for(size_t pos = 0u; pos != ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE>(mMax); ++pos){
+	for(size_t pos = 0u; pos != ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax); ++pos){
 	    const size_t mnpos = PosForward<FT>::valuex(mlast, mStep, pos);
 	    const ExtType npos = last + mExt*pos;
 	    mExpr(mnpos, npos);
 	}
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    inline void For<IndexClass,Expr,FT>::operator()(size_t mlast)
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    inline void For<IndexClass,Expr,FT,DIV>::operator()(size_t mlast)
     {
 	typedef typename IndexClass::RangeType RangeType;
 	ExtType last = rootSteps();
 	last.zero();
-	for(size_t pos = 0u; pos != ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE>(mMax); ++pos){
+	for(size_t pos = 0u; pos != ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax); ++pos){
 	    const size_t mnpos = PosForward<FT>::valuex(mlast, mStep, pos);
 	    const ExtType npos = last + mExt*pos;
 	    mExpr(mnpos, npos);
@@ -668,22 +729,22 @@ namespace MultiArrayHelper
     }
     
     
-    template <class IndexClass, class Expr, ForType FT>
-    auto For<IndexClass,Expr,FT>::rootSteps(std::intptr_t iPtrNum) const
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    auto For<IndexClass,Expr,FT,DIV>::rootSteps(std::intptr_t iPtrNum) const
 	-> ExtType
     {
 	return mExpr.rootSteps(iPtrNum);
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    auto For<IndexClass,Expr,FT>::extension() const
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    auto For<IndexClass,Expr,FT,DIV>::extension() const
 	-> ExtType
     {
 	return mExt;
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    DExt For<IndexClass,Expr,FT>::dRootSteps(std::intptr_t iPtrNum) const
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    DExt For<IndexClass,Expr,FT,DIV>::dRootSteps(std::intptr_t iPtrNum) const
     {
         return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
         //mRootSteps = rootSteps(iPtrNum);
@@ -691,52 +752,54 @@ namespace MultiArrayHelper
 	//					    sizeof(ExtType)/sizeof(size_t));
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    DExt For<IndexClass,Expr,FT>::dExtension() const
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    DExt For<IndexClass,Expr,FT,DIV>::dExtension() const
     {
         return std::make_shared<ExtT<ExtType>>(mExt);
         //return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
 	//					    sizeof(ExtType)/sizeof(size_t));
     }
 
-    template <class IndexClass, class Expr, ForType FT>
-    PFor<IndexClass,Expr> For<IndexClass,Expr,FT>::parallel() const
+    template <class IndexClass, class Expr, ForType FT, size_t DIV>
+    PFor<IndexClass,Expr,DIV> For<IndexClass,Expr,FT,DIV>::parallel() const
     {
         static_assert(FT == ForType::DEFAULT, "hidden for not parallelizable");
-        return PFor<IndexClass,Expr>(mIndPtr, mStep, mExpr);
+        return PFor<IndexClass,Expr,DIV>(mIndPtr, mStep, mExpr);
     }
     
     /******************
      *    P F o r     *
      ******************/
     
-    template <class IndexClass, class Expr>
-    PFor<IndexClass,Expr>::PFor(const std::shared_ptr<IndexClass>& indPtr,
+    template <class IndexClass, class Expr, size_t DIV>
+    PFor<IndexClass,Expr,DIV>::PFor(const std::shared_ptr<IndexClass>& indPtr,
 				 size_t step, Expr expr) :
 	mIndPtr(indPtr.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
         mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
     {
+	assert(mMax % DIV == 0);
 	assert(mIndPtr != nullptr);
     }
 
-    template <class IndexClass, class Expr>
-    PFor<IndexClass,Expr>::PFor(const IndexClass* indPtr,
+    template <class IndexClass, class Expr, size_t DIV>
+    PFor<IndexClass,Expr,DIV>::PFor(const IndexClass* indPtr,
 				 size_t step, Expr expr) :
 	mIndPtr(indPtr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
         mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
     {
+	assert(mMax % DIV == 0);
 	assert(mIndPtr != nullptr);
     }
 
-    template <class IndexClass, class Expr>
-    inline void PFor<IndexClass,Expr>::operator()(size_t mlast, DExt last)
+    template <class IndexClass, class Expr, size_t DIV>
+    inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast, DExt last)
     {
         operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
         //operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
     }
     
-    template <class IndexClass, class Expr>
-    inline void PFor<IndexClass,Expr>::operator()(size_t mlast,
+    template <class IndexClass, class Expr, size_t DIV>
+    inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast,
 						    ExtType last)
     {
         CHECK;
@@ -748,7 +811,7 @@ namespace MultiArrayHelper
         {
             auto expr = mExpr;
 #pragma omp for nowait
-            for(pos = 0; pos < static_cast<int>(ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE>(mMax)); pos++){
+            for(pos = 0; pos < static_cast<int>(ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax)); pos++){
                 mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
                 npos = last + mExt*static_cast<size_t>(pos);
                 expr(mnpos, npos);
@@ -756,11 +819,10 @@ namespace MultiArrayHelper
         }
     }
 
-    template <class IndexClass, class Expr>
-    inline void PFor<IndexClass,Expr>::operator()(size_t mlast)
+    template <class IndexClass, class Expr, size_t DIV>
+    inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast)
     {
         CHECK;
-	typedef typename IndexClass::RangeType RangeType;
 	ExtType last = rootSteps();
 	last.zero();
         int pos = 0;
@@ -771,7 +833,7 @@ namespace MultiArrayHelper
         {
             auto expr = mExpr;
 #pragma omp for nowait
-            for(pos = 0; pos < static_cast<int>(ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE>(mMax)); pos++){
+            for(pos = 0; pos < static_cast<int>(ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax)); pos++){
                 mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
                 npos = last + mExt*static_cast<size_t>(pos);
                 expr(mnpos, npos);
@@ -780,22 +842,22 @@ namespace MultiArrayHelper
     }
     
     
-    template <class IndexClass, class Expr>
-    auto PFor<IndexClass,Expr>::rootSteps(std::intptr_t iPtrNum) const
+    template <class IndexClass, class Expr, size_t DIV>
+    auto PFor<IndexClass,Expr,DIV>::rootSteps(std::intptr_t iPtrNum) const
 	-> ExtType
     {
 	return mExpr.rootSteps(iPtrNum);
     }
 
-    template <class IndexClass, class Expr>
-    auto PFor<IndexClass,Expr>::extension() const
+    template <class IndexClass, class Expr, size_t DIV>
+    auto PFor<IndexClass,Expr,DIV>::extension() const
 	-> ExtType
     {
 	return mExt;
     }
 
-    template <class IndexClass, class Expr>
-    DExt PFor<IndexClass,Expr>::dRootSteps(std::intptr_t iPtrNum) const
+    template <class IndexClass, class Expr, size_t DIV>
+    DExt PFor<IndexClass,Expr,DIV>::dRootSteps(std::intptr_t iPtrNum) const
     {
         return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
         //mRootSteps = rootSteps(iPtrNum);
@@ -803,8 +865,8 @@ namespace MultiArrayHelper
 	//					    sizeof(ExtType)/sizeof(size_t));
     }
 
-    template <class IndexClass, class Expr>
-    DExt PFor<IndexClass,Expr>::dExtension() const
+    template <class IndexClass, class Expr, size_t DIV>
+    DExt PFor<IndexClass,Expr,DIV>::dExtension() const
     {
         return std::make_shared<ExtT<ExtType>>(mExt);
         //return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),

From 269ff69ec31b3ca27096aa390924be05e55924bd Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 24 Jan 2021 00:10:14 +0100
Subject: [PATCH 10/56] automatic vectorization: unit tests work again

---
 src/include/multi_array_operation.cc.h |  9 ++++----
 src/include/multi_array_operation.h    |  2 +-
 src/include/xfor/xfor.h                | 32 +++++++++++++++++++++-----
 src/tests/op3_unit_test.cc             |  1 +
 4 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 64fdecd..dea6150 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -347,7 +347,7 @@ namespace MultiArrayTools
     inline const V& ConstOperationRoot<T,Ranges...>::vget(ET pos) const
     {
 	VCHECK(pos.val());
-	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
+	return *(reinterpret_cast<const V*>(mDataPtr+pos.val()));
     }
 
     template <typename T, class... Ranges>
@@ -614,7 +614,8 @@ namespace MultiArrayTools
 	    CHECK;
 	    typedef typename TarOp::value_type T;
 	    auto x = th.template asx<IVAccess<T,F<T>>>(in);
-	    if(x.divResid() == 0){
+	    if(x.rootSteps(x.vI()) == 1){
+	    //if(0){
 		CHECK;
 		x();
 	    }
@@ -665,7 +666,7 @@ namespace MultiArrayTools
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
 	VCHECK(pos.val());
-	return *(reinterpret_cast<V*>(mDataPtr)+pos.val());
+	return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
 
     template <typename T, class... Ranges>
@@ -843,7 +844,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& ParallelOperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	return *(reinterpret_cast<const V*>(mDataPtr)+pos.val());
+	return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index de33740..3ac063e 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -260,7 +260,7 @@ namespace MultiArrayTools
 	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
 	    VCHECK(pos);
-	    VFunc<F>::selfApply(reinterpret_cast<value_type*>(t)[pos],op.template vget<value_type>(e));
+	    VFunc<F>::selfApply(*reinterpret_cast<value_type*>(t+pos),op.template vget<value_type>(e));
 	}
     };
 
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index c9f6584..d7b7e1e 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -187,8 +187,9 @@ namespace MultiArrayHelper
 	ExpressionBase& operator=(const ExpressionBase& in) = default;
 	ExpressionBase& operator=(ExpressionBase&& in) = default;
 
-	virtual size_t divResid() const { return 0; }
-
+	//virtual size_t divResid() const { return 1; }
+	virtual std::intptr_t vI() const { return 0; }
+	
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const = 0;
 	
 	virtual void operator()(size_t mlast, DExt last) = 0;
@@ -450,7 +451,16 @@ namespace MultiArrayHelper
 	    return std::make_shared<For<IndexClass,Expr,FT,DIV>>(*this);
 	}
 
-	virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
+	//virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
+
+	virtual std::intptr_t vI() const override final
+	{
+	    if(mStep == 1 and LAYER == 1 and mMax % DIV == 0){
+		VCHECK(LAYER);
+		return reinterpret_cast<std::intptr_t>(mIndPtr);
+	    }
+	    return mExpr.vI();
+	}
 
 	template <size_t VS>
 	auto vec() const
@@ -511,7 +521,15 @@ namespace MultiArrayHelper
 	PFor(const IndexClass* indPtr,
 	    size_t step, Expr expr);
 
-	virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
+	//virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
+	virtual std::intptr_t vI() const override final
+	{
+	    if(mStep == 1 and LAYER == 1 and mMax % DIV == 0){
+		VCHECK(LAYER);
+		return reinterpret_cast<std::intptr_t>(mIndPtr);
+	    }
+	    return mExpr.vI();
+	}
 
 	template <size_t VS>
 	auto vec() const
@@ -692,7 +710,9 @@ namespace MultiArrayHelper
 	mIndPtr(indPtr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
         mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
     {
-	assert(mMax % DIV == 0);
+	//VCHECK(mMax);
+	//VCHECK(DIV);
+	//assert(mMax % DIV == 0);
 	assert(mIndPtr != nullptr);
     }
 
@@ -777,7 +797,7 @@ namespace MultiArrayHelper
 	mIndPtr(indPtr.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
         mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
     {
-	assert(mMax % DIV == 0);
+	//assert(mMax % DIV == 0);
 	assert(mIndPtr != nullptr);
     }
 
diff --git a/src/tests/op3_unit_test.cc b/src/tests/op3_unit_test.cc
index 876f9fd..e211634 100644
--- a/src/tests/op3_unit_test.cc
+++ b/src/tests/op3_unit_test.cc
@@ -45,6 +45,7 @@ namespace
 
 	std::clock_t begin = std::clock();
 	res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
+	//res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap);
 	std::clock_t end = std::clock();
 	std::cout << "MultiArray time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
 		  << std::endl;

From 867c20959ab26ec70f40e0aa9646ce4c6612bfcf Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 24 Jan 2021 02:10:06 +0100
Subject: [PATCH 11/56] auto-vectorization works

---
 src/include/map_range.h                |  1 +
 src/include/multi_array_operation.cc.h | 16 +++----
 src/include/multi_array_operation.h    | 11 +++--
 src/include/xfor/xfor.h                | 64 +++++++++++++++++++++-----
 src/tests/op_perf_test.cc              |  8 ++--
 5 files changed, 72 insertions(+), 28 deletions(-)

diff --git a/src/include/map_range.h b/src/include/map_range.h
index 6831cc6..1181a70 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -57,6 +57,7 @@ namespace MultiArrayTools
 	//typedef SingleIndex<typename Op::value_type,STYPE> OIType;
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE + Op::SIZE;
+	static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
 	
     private:
 	OpExpr() = default;
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index dea6150..ab0f068 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -346,7 +346,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline const V& ConstOperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	VCHECK(pos.val());
+	//VCHECK(pos.val());
 	return *(reinterpret_cast<const V*>(mDataPtr+pos.val()));
     }
 
@@ -665,7 +665,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	VCHECK(pos.val());
+	//VCHECK(pos.val());
 	return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
 
@@ -740,12 +740,12 @@ namespace MultiArrayTools
     template <class IOp, class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in) const
         -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                          (mOrigDataPtr,*this,in))))
+                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
 
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mOrigDataPtr,*this,in)));
+                                     (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -763,11 +763,11 @@ namespace MultiArrayTools
     template <class IOp, class OpClass, class Index>
     auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
         -> decltype(i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                      (mOrigDataPtr,*this,in))))
+                                      (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,*this,in)));
+                                 (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -814,7 +814,7 @@ namespace MultiArrayTools
     template <class OpClass>
     ParallelOperationRoot<T,Ranges...>& ParallelOperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-        assign(in)();
+	VExec<OpClass::VABLE>::template exec<identity>(*this,in);
         return *this;
     }
 
@@ -822,7 +822,7 @@ namespace MultiArrayTools
     template <class OpClass>
     ParallelOperationRoot<T,Ranges...>& ParallelOperationRoot<T,Ranges...>::operator+=(const OpClass& in)
     {
-        plus(in)();
+	VExec<OpClass::VABLE>::template exec<xxxplus>(*this,in);
         return *this;
     }
 
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 3ac063e..bb84e8a 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -259,7 +259,7 @@ namespace MultiArrayTools
 	template <typename Op, class ExtType>
 	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
 	{
-	    VCHECK(pos);
+	    //VCHECK(pos);
 	    VFunc<F>::selfApply(*reinterpret_cast<value_type*>(t+pos),op.template vget<value_type>(e));
 	}
     };
@@ -332,6 +332,7 @@ namespace MultiArrayTools
     public:
 
         static constexpr size_t LAYER = 0;
+        static constexpr size_t NHLAYER = 0;
         static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
         typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
 	    
@@ -371,7 +372,8 @@ namespace MultiArrayTools
 
     public:
         static constexpr size_t LAYER = 0;
-        static constexpr size_t SIZE = RootSum<Ops...>::SIZE;
+	static constexpr size_t NHLAYER = 0;
+	static constexpr size_t SIZE = RootSum<Ops...>::SIZE;
         typedef decltype(RootSumN<sizeof...(Ops)-1>::rootSteps(mOps,0) ) ExtType;
 
 	MOp(const Ops&... exprs);
@@ -410,6 +412,7 @@ namespace MultiArrayTools
     public:
 
         static constexpr size_t LAYER = 0;
+	static constexpr size_t NHLAYER = 0;
         static constexpr size_t SIZE = OpClass::SIZE + NextExpr::SIZE;
         typedef decltype(mSec.rootSteps(0).extend( mNExpr.rootSteps(0) ) ) ExtType;
 	    
@@ -699,7 +702,7 @@ namespace MultiArrayTools
         template <class IOp, class OpClass>
         auto asx(const OpClass& in) const
             -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                              (mOrigDataPtr,*this,in))));
+                                              (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
 
         template <class IOp, class OpClass>
         auto asxExpr(const OpClass& in) const
@@ -708,7 +711,7 @@ namespace MultiArrayTools
         template <class IOp, class OpClass, class Index>
         auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const
             -> decltype(i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                          (mOrigDataPtr,*this,in))));
+                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
             
         template <class OpClass>
         auto assign(const OpClass& in) const
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index d7b7e1e..372c334 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -271,6 +271,7 @@ namespace MultiArrayHelper
 	
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
+	static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
 
 	SingleExpression(const SingleExpression& in) = default;
 	SingleExpression& operator=(const SingleExpression& in) = default;
@@ -326,6 +327,7 @@ namespace MultiArrayHelper
 	
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE + 1;
+	static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
 
 	SubExpr(const SubExpr& in) = default;
 	SubExpr& operator=(const SubExpr& in) = default;
@@ -410,6 +412,36 @@ namespace MultiArrayHelper
 	}
     };
 
+    template <ForType FT, size_t LAYER>
+    struct NHLayer
+    {
+	template <class Expr>
+	static constexpr size_t get()
+	{
+	    return Expr::NHLAYER + 1;
+	}
+    };
+
+    template <size_t LAYER>
+    struct NHLayer<ForType::HIDDEN,LAYER>
+    {
+	template <class Expr>
+	static constexpr size_t get()
+	{
+	    return 0;
+	}
+    };
+
+    template <>
+    struct NHLayer<ForType::DEFAULT,1>
+    {
+	template <class Expr>
+	static constexpr size_t get()
+	{
+	    return Expr::LAYER;
+	}
+    };
+
     template <class IndexClass, class Expr, ForType FT, size_t DIV>
     class For : public ExpressionBase
     {
@@ -430,11 +462,12 @@ namespace MultiArrayHelper
         
     public:
 	typedef ExpressionBase EB;
-	
+
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
 	static constexpr size_t MAX = RangeType::SIZE / DIV;
-
+	static constexpr size_t NHLAYER = (FT == ForType::HIDDEN) ? 0 : Expr::NHLAYER + 1;
+	
 	For(const For& in) = default;
 	For& operator=(const For& in) = default;
 	For(For&& in) = default;
@@ -455,8 +488,10 @@ namespace MultiArrayHelper
 
 	virtual std::intptr_t vI() const override final
 	{
-	    if(mStep == 1 and LAYER == 1 and mMax % DIV == 0){
-		VCHECK(LAYER);
+	    if(mStep == 1 and NHLAYER == 1 and mMax % DIV == 0){
+	    //if(mStep == 1 and mMax % DIV == 0){
+		//VCHECK(LAYER);
+		//VCHECK(NHLAYER);
 		return reinterpret_cast<std::intptr_t>(mIndPtr);
 	    }
 	    return mExpr.vI();
@@ -465,9 +500,9 @@ namespace MultiArrayHelper
 	template <size_t VS>
 	auto vec() const
 	{
-	    typedef typename MkVFor<LAYER,RangeType::SIZE % DIV == 0 or RangeType::SIZE == static_cast<size_t>(-1)>::
-		template type<VS,IndexClass,decltype(MkVExpr<LAYER>::template mk<VS>(mExpr)),FT> oType;
-	    return oType(mIndPtr,mStep,MkVExpr<LAYER>::template mk<VS>(mExpr));
+	    typedef typename MkVFor<NHLAYER,RangeType::SIZE % DIV == 0 or RangeType::SIZE == static_cast<size_t>(-1)>::
+		template type<VS,IndexClass,decltype(MkVExpr<NHLAYER>::template mk<VS>(mExpr)),FT> oType;
+	    return oType(mIndPtr,mStep,MkVExpr<NHLAYER>::template mk<VS>(mExpr));
 	}
 
 	inline void operator()(size_t mlast, DExt last) override final;
@@ -509,6 +544,7 @@ namespace MultiArrayHelper
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
 	static constexpr size_t MAX = RangeType::SIZE / DIV;
+	static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
 
 	PFor(const PFor& in) = default;
 	PFor& operator=(const PFor& in) = default;
@@ -524,8 +560,10 @@ namespace MultiArrayHelper
 	//virtual size_t divResid() const override final { return mMax % DIV + MkVExpr<LAYER>::divResid(mExpr); }
 	virtual std::intptr_t vI() const override final
 	{
-	    if(mStep == 1 and LAYER == 1 and mMax % DIV == 0){
-		VCHECK(LAYER);
+	    if(mStep == 1 and NHLAYER == 1 and mMax % DIV == 0){
+	    //if(mStep == 1 and mMax % DIV == 0){
+		//VCHECK(LAYER);
+		//VCHECK(LAYER);
 		return reinterpret_cast<std::intptr_t>(mIndPtr);
 	    }
 	    return mExpr.vI();
@@ -534,9 +572,9 @@ namespace MultiArrayHelper
 	template <size_t VS>
 	auto vec() const
 	{
-	    typedef typename MkVFor<LAYER,RangeType::SIZE % DIV == 0 or RangeType::SIZE == static_cast<size_t>(-1)>::
-		template ptype<VS,IndexClass,decltype(MkVExpr<LAYER>::template mk<VS>(mExpr))> oType;
-	    return oType(mIndPtr,mStep,MkVExpr<LAYER>::template mk<VS>(mExpr));
+	    typedef typename MkVFor<NHLAYER,RangeType::SIZE % DIV == 0 or RangeType::SIZE == static_cast<size_t>(-1)>::
+		template ptype<VS,IndexClass,decltype(MkVExpr<NHLAYER>::template mk<VS>(mExpr))> oType;
+	    return oType(mIndPtr,mStep,MkVExpr<NHLAYER>::template mk<VS>(mExpr));
 	}
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
@@ -574,6 +612,7 @@ namespace MultiArrayHelper
 	
 	static constexpr size_t LAYER = 0;
 	static constexpr size_t SIZE = 0;
+	static constexpr size_t NHLAYER = 0;
 
 	DynamicExpression(const DynamicExpression& in) :
 	    mThreadId(omp_get_thread_num()),
@@ -649,6 +688,7 @@ namespace MultiArrayHelper
 	
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
+	static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
 
 	ExpressionHolder(const ExpressionHolder& in) = default;
 	ExpressionHolder(ExpressionHolder&& in) = default;
diff --git a/src/tests/op_perf_test.cc b/src/tests/op_perf_test.cc
index 131db7e..90c711d 100644
--- a/src/tests/op_perf_test.cc
+++ b/src/tests/op_perf_test.cc
@@ -174,8 +174,8 @@ namespace {
 	auto beta = MAT::getIndex<SR>();
 	auto gamma = MAT::getIndex<SR>();
 	auto delta = MAT::getIndex<SR>();
-	//auto deltap = MAT::getIndex<SR>();
-	auto deltap = MAT::getIndex<GenSingleRange<size_t,SpaceType::NONE,1>>();
+	auto deltap = MAT::getIndex<SR>();
+	//auto deltap = MAT::getIndex<GenSingleRange<size_t,SpaceType::NONE,1>>();
 	
 	auto mix = MAT::mkMIndex( jj, alpha, beta, gamma );
 
@@ -217,8 +217,8 @@ namespace {
         
         auto begin = std::chrono::system_clock::now();
 	//for(size_t i = 0; i != os; ++i){
-        //res1(ii ,delta, deltap).par() += ma(ii, delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
-        tcast<v256>(res1)(ii ,delta, deltap).par() += tcast<v256>(ma)(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
+        res1(ii ,delta, deltap).par() += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
+        //tcast<v256>(res1)(ii ,delta, deltap).par() += tcast<v256>(ma)(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
 	//}
         auto end = std::chrono::system_clock::now();
 	std::cout << "MultiArray time: " << std::chrono::duration<double>(end-begin).count()

From c608239ced962d5bf92bce98448467cdf7b8ee43 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 3 Feb 2021 14:30:25 +0100
Subject: [PATCH 12/56] various fixes

---
 src/include/multi_array_operation.h | 11 ++++++-----
 src/include/type_operations.h       | 14 ++++++++++++++
 src/include/xfor/iloop.h            |  3 +++
 3 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index bb84e8a..ea90758 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -8,6 +8,7 @@
 #include <cmath>
 #include <map>
 #include <utility>
+#include <type_traits>
 
 #include "base_def.h"
 #include "mbase_def.h"
@@ -792,16 +793,16 @@ namespace MultiArrayTools
 	T mVal;
     };
 
-    template <class Op> 
+    template <typename T, class Op> 
     inline constexpr bool isVAble()
     {
-	return Op::VABLE;
+	return Op::VABLE and std::is_same<T,typename Op::value_type>::value;
     }
 
-    template <class Op1, class Op2, class... Ops>
+    template <typename T, class Op1, class Op2, class... Ops>
     inline constexpr bool isVAble()
     {
-	return Op1::VABLE and isVAble<Op2,Ops...>();
+	return Op1::VABLE and std::is_same<T,typename Op1::value_type>::value and isVAble<T,Op2,Ops...>();
     }
     
     template <typename T, class OpFunction, class... Ops>
@@ -816,7 +817,7 @@ namespace MultiArrayTools
 	static constexpr size_t SIZE = RootSum<Ops...>::SIZE;
 	static constexpr bool FISSTATIC = OpFunction::FISSTATIC;
         static constexpr bool CONT = false;
-        static constexpr bool VABLE = isVAble<Ops...>();
+        static constexpr bool VABLE = isVAble<T,Ops...>();
 
     private:
 	std::tuple<Ops...> mOps;
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index 7b438f2..f38c243 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -500,6 +500,20 @@ namespace MultiArrayTools
 	return out;
     }
 
+    inline double xsqrt(const double& a)
+    {
+	return sqrt(a);
+    }
+
+    inline v256 sqrt(const v256& a)
+    {
+	v256 out;
+	for(int i = 0; i < 4; i++){
+	    out._x[i] = xsqrt(a._x[i]);
+	}
+	return out;
+    }
+
 } // namespace MultiArrayTools
 
 #endif
diff --git a/src/include/xfor/iloop.h b/src/include/xfor/iloop.h
index 0bad5a0..1afcc46 100644
--- a/src/include/xfor/iloop.h
+++ b/src/include/xfor/iloop.h
@@ -116,6 +116,7 @@ namespace MultiArrayHelper
             
     public:
         //static constexpr size_t SIZE = NN<LTpSize-1>::lsize(std::declval<LTp>());
+	static constexpr size_t NHLAYER = 10; // some large value
         static constexpr size_t SIZE = NN<LTpSize-1>::template LSIZE<LTp>();
         static constexpr bool CONT = false;
         typedef decltype(NN<LTpSize-1>::rootSteps(mLTp)) ExtType;
@@ -248,6 +249,8 @@ namespace MultiArrayHelper
         static constexpr size_t VarTpSize = LType::VarTpSize;
             
     public:
+
+	static constexpr size_t NHLAYER = 10; // some large value
         static constexpr size_t SIZE = LType::SIZE;
         static constexpr bool CONT = LType::CONT;
         typedef typename LType::ExtType ExtType;

From 70c850be2f271fdf7357e8cea53c14f8b7d0cc85 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 4 Apr 2021 14:21:09 +0200
Subject: [PATCH 13/56] basic_types

---
 src/include/basic_types.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 src/include/basic_types.h

diff --git a/src/include/basic_types.h b/src/include/basic_types.h
new file mode 100644
index 0000000..78884c3
--- /dev/null
+++ b/src/include/basic_types.h
@@ -0,0 +1,18 @@
+#ifndef __basic_types_h__
+#define __basic_types_h__
+
+#include <string>
+
+namespace MultiArrayTools
+{
+
+    // just to fix this forever:
+    typedef int32_t Int;
+    typedef uint64_t SizeT;
+    typedef double Double;
+    typedef Double Real;
+    typedef std::string String;
+    
+}
+
+#endif

From cf1850923fdd404ef1b831d425961d40f3dd5e90 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 4 Apr 2021 15:10:15 +0200
Subject: [PATCH 14/56] name mapping suggestions + static cc for implementation

---
 src/include/statics/static_for.h | 68 ++++++++++++++++++++++++++++++++
 src/name_map.txt                 |  7 ++++
 2 files changed, 75 insertions(+)
 create mode 100644 src/include/statics/static_for.h
 create mode 100644 src/name_map.txt

diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
new file mode 100644
index 0000000..fb12618
--- /dev/null
+++ b/src/include/statics/static_for.h
@@ -0,0 +1,68 @@
+
+#ifndef __static_for_h__
+#define __static_for_h__
+
+#include <cstdlib>
+
+namespace MultiArrayTools
+{
+
+    template <size_t BEG, size_t END>
+    struct sfor
+    {
+	template <typename F>
+	static void execs(const F& f)
+	{
+	    if(BEG < END){
+		f(std::integral_constant<size_t, BEG>{});
+		sfor<BEG+1,END>::execs(f);
+	    }
+	}
+
+	template <typename F>
+	static void execsr(const F& f)
+	{
+	    if(BEG < END){
+		f(std::integral_constant<size_t, END-1>{});
+		sfor<BEG,END-1>::execsr(f);
+	    }
+	}
+
+	template <typename F>
+	static void exec(const F& f)
+	{
+	    f(std::integral_constant<size_t, BEG>{});
+	    sfor<BEG+1,END>::exec(f);
+	}
+
+	template <typename F>
+	static void execr(const F& f)
+	{
+	    f(std::integral_constant<size_t, END-1>{});
+	    sfor<BEG,END-1>::execr(f);
+	}
+    };
+
+    template <size_t N>
+    struct sfor<N,N>
+    {
+	template <typename F>
+	static void execs(const F& f) {}
+
+    	template <typename F>
+	static void execsr(const F& f) {}
+
+    	template <typename F>
+	static void exec(const F& f) {}
+
+    	template <typename F>
+	static void execr(const F& f) {}
+    };
+}
+
+#define MA_SSFOR(i,beg,end,expr) MultiArrayTools::sfor<beg,end>::execs([&](auto i){ expr })
+#define MA_SSRFOR(i,end,beg,expr) MultiArrayTools::sfor<beg,end>::execsr([&](auto i){ expr })
+#define MA_SFOR(i,beg,end,expr) MultiArrayTools::sfor<beg,end>::exec([&](auto i){ expr })
+#define MA_SRFOR(i,end,beg,expr) MultiArrayTools::sfor<beg,end>::execr([&](auto i){ expr })
+
+#endif
diff --git a/src/name_map.txt b/src/name_map.txt
new file mode 100644
index 0000000..f38a7a5
--- /dev/null
+++ b/src/name_map.txt
@@ -0,0 +1,7 @@
+:: Rename MultiArray library in CNORXZ (Containers with Native Operation Routines by XZ (chizeta))
+MultiArrayTools -> CNORXZ
+MultiArray -> Array
+multi_array_*.{cc,h} -> cxz_*.{cc,h}
+*ma* -> *cxz*
+libmultiarray -> libcnorxz
+...!!!

From 48084b2a5e4ab48613b17c2a4cc2c9580c500ed7 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sat, 10 Apr 2021 00:58:30 +0200
Subject: [PATCH 15/56] generalize static_for.h

---
 src/include/statics/static_for.h | 77 ++++++++++++++------------------
 1 file changed, 33 insertions(+), 44 deletions(-)

diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index fb12618..abc0c87 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -7,62 +7,51 @@
 namespace MultiArrayTools
 {
 
-    template <size_t BEG, size_t END>
+    template <size_t BEG, size_t END, size_t OFF>
     struct sfor
     {
-	template <typename F>
-	static void execs(const F& f)
+	template <typename Incr, typename F, typename Conc>
+	static inline auto exec(Incr incr, F f, Conc conc)
 	{
-	    if(BEG < END){
-		f(std::integral_constant<size_t, BEG>{});
-		sfor<BEG+1,END>::execs(f);
-	    }
+	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+	    static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+			  "this turns out to be a static endless loop");
+	    auto tmp = f(idxm);
+	    return conc(tmp, static_for<incr(idx),END,OFF>::exec(incr,f,conc));
 	}
-
-	template <typename F>
-	static void execsr(const F& f)
+	
+	template <typename Incr, typename F, typename Create, typename... Args>
+	static inline auto unpack(Incr incr, F f, Create create, const Args&... args)
 	{
-	    if(BEG < END){
-		f(std::integral_constant<size_t, END-1>{});
-		sfor<BEG,END-1>::execsr(f);
-	    }
-	}
-
-	template <typename F>
-	static void exec(const F& f)
-	{
-	    f(std::integral_constant<size_t, BEG>{});
-	    sfor<BEG+1,END>::exec(f);
-	}
-
-	template <typename F>
-	static void execr(const F& f)
-	{
-	    f(std::integral_constant<size_t, END-1>{});
-	    sfor<BEG,END-1>::execr(f);
+	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+	    static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+			  "this turns out to be a static endless loop");
+	    auto tmp = f(idxm);
+	    return static_for<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
 	}
     };
 
-    template <size_t N>
-    struct sfor<N,N>
+    template <size_t END, size_t OFF>
+    struct sfor<END,END,OFF>
     {
-	template <typename F>
-	static void execs(const F& f) {}
+	template <typename Incr, typename F, typename Conc>
+	static inline auto exec(Incr incr, F f, Conc conc)
+	{
+	    return 0;
+	}
 
-    	template <typename F>
-	static void execsr(const F& f) {}
-
-    	template <typename F>
-	static void exec(const F& f) {}
-
-    	template <typename F>
-	static void execr(const F& f) {}
+	template <typename Incr, typename F, typename Create, typename... Args>
+	static inline auto unpack(Incr incr, F f, Create create, const Args&... args)
+	{
+	    return create(args...);
+	}
     };
 }
 
-#define MA_SSFOR(i,beg,end,expr) MultiArrayTools::sfor<beg,end>::execs([&](auto i){ expr })
-#define MA_SSRFOR(i,end,beg,expr) MultiArrayTools::sfor<beg,end>::execsr([&](auto i){ expr })
-#define MA_SFOR(i,beg,end,expr) MultiArrayTools::sfor<beg,end>::exec([&](auto i){ expr })
-#define MA_SRFOR(i,end,beg,expr) MultiArrayTools::sfor<beg,end>::execr([&](auto i){ expr })
+#define MA_SFOR(i,beg,end,incr,expr) static_for<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
+#define MA_SRFOR(i,beg,end,decr,expr) static_for<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
+#define MA_CFOR(i,beg,end,incr,expr,cre) static_for<beg,end,0>::unpack([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
 
 #endif

From 64c5c2b4f30b361fc9dff0b7a5dbe521a77388a1 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sat, 10 Apr 2021 13:25:43 +0200
Subject: [PATCH 16/56] -> C++17

---
 CMakeLists.txt                      |  2 +-
 src/include/extensions/math.h       | 24 ------------------------
 src/include/multi_array_operation.h | 13 +------------
 3 files changed, 2 insertions(+), 37 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index bacd260..5626d0f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ else()
   message(WARNING "compiler ${CMAKE_CXX_COMPILER_ID} officially not supported")
 endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -std=c++14 -Wpedantic -Ofast -march=native -faligned-new -funroll-loops -fopenmp")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -std=c++17 -Wpedantic -Ofast -march=native -faligned-new -funroll-loops -fopenmp")
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -std=c++14 -g -Wpedantic -Ofast -march=native -faligned-new -funroll-loops -fopenmp -ftemplate-backtrace-limit=0")
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -std=c++14 -g -Wpedantic -O0 -march=native -faligned-new -funroll-loops -fopenmp")
 
diff --git a/src/include/extensions/math.h b/src/include/extensions/math.h
index 5887bf3..b1f9183 100644
--- a/src/include/extensions/math.h
+++ b/src/include/extensions/math.h
@@ -2,29 +2,5 @@
 #ifdef regFunc1
 
 regFunc1(exp)
-regFunc1(exp2)
-regFunc1(expm1)
-regFunc1(log)
-regFunc1(log10)
-regFunc1(log2)
-regFunc1(log1p)
-regFunc1(sqrt)
-regFunc1(cbrt)
-regFunc1(sin)
-regFunc1(cos)
-regFunc1(tan)
-regFunc1(asin)
-regFunc1(acos)
-regFunc1(atan)
-regFunc1(sinh)
-regFunc1(cosh)
-regFunc1(tanh)
-regFunc1(asinh)
-regFunc1(acosh)
-regFunc1(atanh)
-regFunc1(erf)
-regFunc1(erfc)
-regFunc1(tgamma)
-regFunc1(lgamma)
 
 #endif
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 6e852f7..7837db6 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -102,18 +102,6 @@ namespace MultiArrayTools
 	friend OperationClass;
     };
 
-    template <class Op>
-    size_t sumRootNum()
-    {
-	return typename Op::rootNum();
-    }
-    
-    template <class Op1, class Op2, class... Ops>
-    size_t sumRootNum()
-    {
-	return typename Op1::rootNum() + sumRootNum<Op2,Ops...>();
-    }
-
     template <size_t N>
     struct RootSumN
     {
@@ -190,6 +178,7 @@ namespace MultiArrayTools
     template <class... Ops>
     struct RootSum
     {
+	//static constexpr size_t SIZE = (... + Ops::SIZE);
 	static constexpr size_t SIZE = RootSumN<sizeof...(Ops)-1>::template rs<Ops...>::SIZE;
     };
 

From 1f663e0b76b9c1d5398272db422e1885cfb69295 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sat, 10 Apr 2021 16:06:02 +0200
Subject: [PATCH 17/56] start replacement PackNum -> SFOR

---
 src/include/multi_array_operation.cc.h |  11 +--
 src/include/multi_array_operation.h    | 122 +++----------------------
 src/include/statics/static_for.h       |  48 +++++++---
 3 files changed, 56 insertions(+), 125 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index da2ecbb..e3f578a 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -245,9 +245,10 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Ops>
-    auto MOp<T,Ops...>::rootSteps(std::intptr_t iPtrNum) const -> ExtType
+    auto MOp<T,Ops...>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return RootSumN<sizeof...(Ops)-1>::rootSteps(mOps,iPtrNum);
+	return MA_SCFOR(i,0,sizeof...(Ops),i+1,std::get<i>(mOps).rootSteps(iPtrNum),extend);
+	//return RootSumN<sizeof...(Ops)-1>::rootSteps(mOps,iPtrNum);
     }
 
     template <class OpClass, class NextExpr>
@@ -1011,17 +1012,15 @@ namespace MultiArrayTools
 
     template <typename T, class OpFunction, class... Ops>
     auto Operation<T,OpFunction,Ops...>::rootSteps(std::intptr_t iPtrNum) const
-	-> decltype(PackNum<sizeof...(Ops)-1>::mkSteps(iPtrNum, mOps))
     {
-	return PackNum<sizeof...(Ops)-1>::mkSteps(iPtrNum, mOps);
+	return MA_SCFOR(i,0,sizeof...(Ops),i+1,std::get<i>(mOps).rootSteps(iPtrNum),extend);
     }
 
     template <typename T, class OpFunction, class... Ops>
     template <class Expr>
     auto Operation<T,OpFunction,Ops...>::loop(Expr exp) const
-	-> decltype(PackNum<sizeof...(Ops)-1>::mkLoop( mOps, exp ))
     {
-	return PackNum<sizeof...(Ops)-1>::mkLoop( mOps, exp );
+	return MA_SCRAFOR(i,sizeof...(Ops),0,i-1,std::get<i>(mOps),loop,exp);
     }
 
     
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 7837db6..e9ff90f 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -20,6 +20,8 @@
 #include "xfor/xfor.h"
 #include "type_operations.h"
 
+#include "statics/static_for.h"
+
 namespace MultiArrayTools
 {
 
@@ -105,11 +107,6 @@ namespace MultiArrayTools
     template <size_t N>
     struct RootSumN
     {
-	template <class Op1, class... Ops>
-	struct rs
-	{
-	    static constexpr size_t SIZE = Op1::SIZE + RootSumN<N-1>::template rs<Ops...>::SIZE;
-	};
 
 	template <class... Exprs>
 	static inline auto rootSteps(const std::tuple<Exprs...>& etp, std::intptr_t i)
@@ -142,11 +139,6 @@ namespace MultiArrayTools
     template <>
     struct RootSumN<0>
     {
-	template <class Op1>
-	struct rs
-	{
-	    static constexpr size_t SIZE = Op1::SIZE;
-	};
 
 	template <class... Exprs>
 	static inline auto rootSteps(const std::tuple<Exprs...>& etp, std::intptr_t i)
@@ -175,14 +167,6 @@ namespace MultiArrayTools
     };
 
     
-    template <class... Ops>
-    struct RootSum
-    {
-	//static constexpr size_t SIZE = (... + Ops::SIZE);
-	static constexpr size_t SIZE = RootSumN<sizeof...(Ops)-1>::template rs<Ops...>::SIZE;
-    };
-
-    
     template <typename T>
     struct SelfIdentity
     {
@@ -271,46 +255,6 @@ namespace MultiArrayTools
 
     template <typename T>
     using IVPlus = IVAccess<T,plus<T>>;
-    /*
-    struct IAssign
-    {
-	template <typename T, typename Op, class ExtType>
-	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
-	{
-	    t[pos] = op.get(e);
-	}
-    };
-
-    template <typename V>
-    struct IVAssign
-    {
-	template <typename T, typename Op, class ExtType>
-	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
-	{
-	    reinterpret_cast<V*>(t)[pos] = op.template vget<V>(e);
-	}
-    };
-    
-    struct IPlus
-    {
-	template <typename T, typename Op, class ExtType>
-	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
-	{
-	    t[pos] += op.get(e);
-	}
-    };
-
-    template <typename V>
-    struct IVPlus
-    {
-	template <typename T, typename Op, class ExtType>
-	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
-	{
-	    reinterpret_cast<V*>(t)[pos] += op.template vget<V>(e);
-	}
-    };
-    */
-
     
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
@@ -366,7 +310,7 @@ namespace MultiArrayTools
     public:
         static constexpr size_t LAYER = 0;
 	static constexpr size_t NHLAYER = 0;
-	static constexpr size_t SIZE = RootSum<Ops...>::SIZE;
+	static constexpr size_t SIZE = (... + Ops::SIZE);
         typedef decltype(RootSumN<sizeof...(Ops)-1>::rootSteps(mOps,0) ) ExtType;
 
 	MOp(const Ops&... exprs);
@@ -382,7 +326,7 @@ namespace MultiArrayTools
 	inline size_t vget(ExtType last) const { return get(last); }
 	
 	inline MOp& set(ExtType last);
-        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
+        auto rootSteps(std::intptr_t iPtrNum = 0) const;
 
 	template <class Expr>
 	auto loop(Expr exp) const
@@ -821,18 +765,6 @@ namespace MultiArrayTools
 
 	T const** data() const { assert(0); return nullptr; }
     };
-
-    template <typename T, class Op> 
-    inline constexpr bool isVAble()
-    {
-	return Op::VABLE and std::is_same<T,typename Op::value_type>::value;
-    }
-
-    template <typename T, class Op1, class Op2, class... Ops>
-    inline constexpr bool isVAble()
-    {
-	return Op1::VABLE and std::is_same<T,typename Op1::value_type>::value and isVAble<T,Op2,Ops...>();
-    }
     
     template <typename T, class OpFunction, class... Ops>
     class Operation : public OperationTemplate<T,Operation<T,OpFunction,Ops...> >
@@ -843,17 +775,17 @@ namespace MultiArrayTools
 	typedef OperationBase<T,Operation<T,OpFunction,Ops...> > OT;
 	typedef OpFunction F;
 	
-	static constexpr size_t SIZE = RootSum<Ops...>::SIZE;
+	static constexpr size_t SIZE = (... + Ops::SIZE);
 	static constexpr bool FISSTATIC = OpFunction::FISSTATIC;
         static constexpr bool CONT = false;
-        static constexpr bool VABLE = isVAble<T,Ops...>();
+	static constexpr bool VABLE =
+	    (... and (Ops::VABLE and std::is_same<T,typename Ops::value_type>::value));
 
     private:
 	std::tuple<Ops...> mOps;
 	std::shared_ptr<OpFunction> mF; // only if non-static
 	
     public:
-	typedef decltype(PackNum<sizeof...(Ops)-1>::template mkSteps<Ops...>(0, mOps)) ETuple;
 		
 	Operation(const Ops&... ops);
 	Operation(std::shared_ptr<OpFunction> ff, const Ops&... ops);
@@ -867,49 +799,25 @@ namespace MultiArrayTools
 	template <class ET>
 	inline Operation& set(ET pos);
 
-	auto rootSteps(std::intptr_t iPtrNum = 0) const // nullptr for simple usage with decltype
-	    -> decltype(PackNum<sizeof...(Ops)-1>::mkSteps(iPtrNum, mOps));
+	auto rootSteps(std::intptr_t iPtrNum = 0) const; // nullptr for simple usage with decltype
 
 	template <class Expr>
-	auto loop(Expr exp) const
-	    -> decltype(PackNum<sizeof...(Ops)-1>::mkLoop( mOps, exp));
+	auto loop(Expr exp) const;
 
 	T* data() const { assert(0); return nullptr; }
     };
-
-    namespace
-    {
-	template <bool FISSTATIC>
-	struct OpMaker
-	{
-	    template <class OpFunction, class... Ops>
-	    static inline auto mkOperation(const std::shared_ptr<OpFunction>& f, const Ops&... ops)
-		-> Operation<typename OpFunction::value_type,OpFunction,Ops...>
-	    {
-		return Operation<typename OpFunction::value_type,OpFunction,Ops...>(f,ops...);
-	    }
-	};
-
-	template <>
-	struct OpMaker<true>
-	{
-	    template <class OpFunction, class... Ops>
-	    static inline auto mkOperation(const std::shared_ptr<OpFunction>& f, const Ops&... ops)
-		-> Operation<typename OpFunction::value_type,OpFunction,Ops...>
-	    {
-		return Operation<typename OpFunction::value_type,OpFunction,Ops...>(ops...);
-	    }
-	};
-
-    }
     
     template <class OpFunction, class... Ops>
     auto mkOperation(const std::shared_ptr<OpFunction>& f, const Ops&... ops)
 	-> Operation<typename OpFunction::value_type,OpFunction,Ops...>
     {
-	return OpMaker<OpFunction::FISSTATIC>::mkOperation(f, ops...);
+	if constexpr(OpFunction::FISSTATIC){
+	    return Operation<typename OpFunction::value_type,OpFunction,Ops...>(ops...);
+	}
+	else {
+	    return Operation<typename OpFunction::value_type,OpFunction,Ops...>(f,ops...);
+	}
     }
-
     
     template <typename T, class Op, class IndexType>
     class Contraction : public OperationTemplate<T,Contraction<T,Op,IndexType> >
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index abc0c87..a8c21a1 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -7,7 +7,7 @@
 namespace MultiArrayTools
 {
 
-    template <size_t BEG, size_t END, size_t OFF>
+    template <size_t BEG, size_t END, int OFF>
     struct sfor
     {
 	template <typename Incr, typename F, typename Conc>
@@ -15,25 +15,46 @@ namespace MultiArrayTools
 	{
 	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
 	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
-	    static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
-			  "this turns out to be a static endless loop");
+	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+	    //		  "this turns out to be a static endless loop");
 	    auto tmp = f(idxm);
-	    return conc(tmp, static_for<incr(idx),END,OFF>::exec(incr,f,conc));
+	    if constexpr(incr(idx) == END){
+		return tmp;
+	    }
+	    else {
+		return conc(tmp, sfor<incr(idx),END,OFF>::exec(incr,f,conc));
+	    }
 	}
-	
+
+	template <typename Incr, typename F, typename Conc, typename Arg>
+	static inline auto exec(Incr incr, F f, Conc conc, const Arg& arg)
+	{
+	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+	    //		  "this turns out to be a static endless loop");
+	    auto tmp = f(idxm);
+	    if constexpr(incr(idx) == END){
+		return conc(tmp, arg);
+	    }
+	    else {
+		return conc(tmp, sfor<incr(idx),END,OFF>::exec(incr,f,conc,arg));
+	    }
+	}
+
 	template <typename Incr, typename F, typename Create, typename... Args>
 	static inline auto unpack(Incr incr, F f, Create create, const Args&... args)
 	{
 	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
 	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
-	    static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
-			  "this turns out to be a static endless loop");
+	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+	    //		  "this turns out to be a static endless loop");
 	    auto tmp = f(idxm);
-	    return static_for<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
+	    return sfor<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
 	}
     };
 
-    template <size_t END, size_t OFF>
+    template <size_t END, int OFF>
     struct sfor<END,END,OFF>
     {
 	template <typename Incr, typename F, typename Conc>
@@ -50,8 +71,11 @@ namespace MultiArrayTools
     };
 }
 
-#define MA_SFOR(i,beg,end,incr,expr) static_for<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
-#define MA_SRFOR(i,beg,end,decr,expr) static_for<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
-#define MA_CFOR(i,beg,end,incr,expr,cre) static_for<beg,end,0>::unpack([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
+#define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
+#define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
+#define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
+#define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
+#define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
+#define MA_CFOR(i,beg,end,incr,expr,cre) sfor<beg,end,0>::unpack([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
 
 #endif

From fe22b1ad8090287325d1a678f5e4661e136a6331 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 11 Apr 2021 16:34:01 +0200
Subject: [PATCH 18/56] im com + remove Getter class

---
 src/include/map_range.cc.h             |   4 +-
 src/include/multi_array_operation.cc.h |  23 ++-
 src/include/multi_array_operation.h    |  35 +++-
 src/include/pack_num.h                 |  21 +-
 src/include/statics/static_for.h       |  25 +--
 src/include/xfor/exttype.h             | 262 +++++++++++++++++++++----
 src/include/xfor/xfor.h                | 156 +--------------
 7 files changed, 279 insertions(+), 247 deletions(-)

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 8f786dd..4495c58 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -49,7 +49,7 @@ namespace MultiArrayTools
         if(pos != mIndPtr->max()){
             const ExtType npos = last + mExt*pos;
             const size_t mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
-            mExpr(mnpos, Getter<NEXT>::template getX<ExtType>( npos ) );
+            mExpr(mnpos, getX<NEXT>( npos ) );
         }
     }
 
@@ -63,7 +63,7 @@ namespace MultiArrayTools
         if(pos != mIndPtr->max()){
             const ExtType npos = last + mExt*pos;
             const size_t mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
-            mExpr(mnpos, Getter<NEXT>::template getX<ExtType>( npos ));
+            mExpr(mnpos, getX<NEXT>( npos ));
         }
     }
     
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index e3f578a..6c0644f 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -226,29 +226,27 @@ namespace MultiArrayTools
     template <typename T, class... Ops>
     inline size_t MOp<T,Ops...>::get(ExtType last) const
     {
-	return RootSumN<sizeof...(Ops)-1>::get(last,mOps);
+	return RootSumN<sizeof...(Ops)-1>::get(last,mOps.mOps);
     }
 
     template <typename T, class... Ops>
     inline MOp<T,Ops...>& MOp<T,Ops...>::set(ExtType last)
     {
-	RootSumN<sizeof...(Ops)-1>::set(last,mOps);
+	RootSumN<sizeof...(Ops)-1>::set(last,mOps.mOps);
 	return *this;
     }
     
     template <typename T, class... Ops>
     template <class Expr>
     auto MOp<T,Ops...>::loop(Expr exp) const
-	-> decltype(PackNum<sizeof...(Ops)-1>::mkLoop( mOps, exp))
     {
-	return PackNum<sizeof...(Ops)-1>::mkLoop( mOps, exp);
+	return MA_SCRAFOR(i,sizeof...(Ops),0,i-1,std::get<i>(mOps.mOps),loop,exp);
     }
 
     template <typename T, class... Ops>
-    auto MOp<T,Ops...>::rootSteps(std::intptr_t iPtrNum) const
+    auto MOp<T,Ops...>::rootSteps(std::intptr_t iPtrNum) const -> ExtType
     {
-	return MA_SCFOR(i,0,sizeof...(Ops),i+1,std::get<i>(mOps).rootSteps(iPtrNum),extend);
-	//return RootSumN<sizeof...(Ops)-1>::rootSteps(mOps,iPtrNum);
+	return mOps.rootSteps(iPtrNum);
     }
 
     template <class OpClass, class NextExpr>
@@ -989,7 +987,7 @@ namespace MultiArrayTools
     {
 	typedef std::tuple<Ops...> OpTuple;
 	return PackNum<sizeof...(Ops)-1>::
-	    template mkOpExpr<SIZE,ET,OpTuple,OpFunction>(mF, pos, mOps);
+	    template mkOpExpr<SIZE,ET,OpTuple,OpFunction>(mF, pos, mOps.mOps);
     }
 
     template <typename T, class OpFunction, class... Ops>
@@ -998,7 +996,7 @@ namespace MultiArrayTools
     {
 	typedef std::tuple<Ops...> OpTuple;
 	return PackNum<sizeof...(Ops)-1>::
-	    template mkVOpExpr<SIZE,V,ET,OpTuple,VFunc<OpFunction>>(mkVFuncPtr(mF), pos, mOps); // implement!!!
+	    template mkVOpExpr<SIZE,V,ET,OpTuple,VFunc<OpFunction>>(mkVFuncPtr(mF), pos, mOps.mOps); // implement!!!
     }
 
     template <typename T, class OpFunction, class... Ops>
@@ -1006,21 +1004,22 @@ namespace MultiArrayTools
     inline Operation<T,OpFunction,Ops...>& Operation<T,OpFunction,Ops...>::set(ET pos)
     {
 	typedef std::tuple<Ops...> OpTuple;
-	PackNum<sizeof...(Ops)-1>::template setOpPos<SIZE,OpTuple,ET>(mOps,pos);
+	PackNum<sizeof...(Ops)-1>::template setOpPos<SIZE,OpTuple,ET>(mOps.mOps,pos);
 	return *this;
     }
 
     template <typename T, class OpFunction, class... Ops>
     auto Operation<T,OpFunction,Ops...>::rootSteps(std::intptr_t iPtrNum) const
+	-> ExtType
     {
-	return MA_SCFOR(i,0,sizeof...(Ops),i+1,std::get<i>(mOps).rootSteps(iPtrNum),extend);
+	return mOps.rootSteps(iPtrNum);
     }
 
     template <typename T, class OpFunction, class... Ops>
     template <class Expr>
     auto Operation<T,OpFunction,Ops...>::loop(Expr exp) const
     {
-	return MA_SCRAFOR(i,sizeof...(Ops),0,i-1,std::get<i>(mOps),loop,exp);
+	return MA_SCRAFOR(i,sizeof...(Ops),0,i-1,std::get<i>(mOps.mOps),loop,exp);
     }
 
     
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index e9ff90f..fedbec5 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -300,19 +300,33 @@ namespace MultiArrayTools
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     using AddExpr = AssignmentExpr<T,IPlus<T>,Target,OpClass,OIA>;
 
+    template <class... Ops>
+    struct OperationTuple
+    {
+	OperationTuple(const Ops&... ops) : mOps(ops...) {}
+	std::tuple<Ops...> mOps;
+	auto rootSteps(std::intptr_t iPtrNum) const;
+    };
+
+    template <class... Ops>
+    auto OperationTuple<Ops...>::rootSteps(std::intptr_t iPtrNum) const
+    {
+	return MA_SCFOR(i,0,sizeof...(Ops),i+1,std::get<i>(mOps).rootSteps(iPtrNum),extend);
+    }
+    
     template <typename T, class... Ops>
     class MOp
     {
     private:
 	MOp() = default;
-	std::tuple<Ops...> mOps;
-
+	OperationTuple<Ops...> mOps;
+	
     public:
         static constexpr size_t LAYER = 0;
 	static constexpr size_t NHLAYER = 0;
 	static constexpr size_t SIZE = (... + Ops::SIZE);
-        typedef decltype(RootSumN<sizeof...(Ops)-1>::rootSteps(mOps,0) ) ExtType;
-
+	typedef decltype(mOps.rootSteps(0)) ExtType;
+	
 	MOp(const Ops&... exprs);
 	
 	MOp(const MOp& in) = default;
@@ -326,11 +340,10 @@ namespace MultiArrayTools
 	inline size_t vget(ExtType last) const { return get(last); }
 	
 	inline MOp& set(ExtType last);
-        auto rootSteps(std::intptr_t iPtrNum = 0) const;
+        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
 
 	template <class Expr>
-	auto loop(Expr exp) const
-	    -> decltype(PackNum<sizeof...(Ops)-1>::mkLoop( mOps, exp));
+	auto loop(Expr exp) const;
 
 	T* data() const { assert(0); return nullptr; }
 
@@ -782,8 +795,9 @@ namespace MultiArrayTools
 	    (... and (Ops::VABLE and std::is_same<T,typename Ops::value_type>::value));
 
     private:
-	std::tuple<Ops...> mOps;
+	OperationTuple<Ops...> mOps;
 	std::shared_ptr<OpFunction> mF; // only if non-static
+	typedef decltype(mOps.rootSteps(0)) ExtType;
 	
     public:
 		
@@ -798,8 +812,9 @@ namespace MultiArrayTools
 
 	template <class ET>
 	inline Operation& set(ET pos);
-
-	auto rootSteps(std::intptr_t iPtrNum = 0) const; // nullptr for simple usage with decltype
+	
+	auto rootSteps(std::intptr_t iPtrNum = 0) const
+	    -> ExtType; // nullptr for simple usage with decltype
 
 	template <class Expr>
 	auto loop(Expr exp) const;
diff --git a/src/include/pack_num.h b/src/include/pack_num.h
index 234e6bf..4f8c3b1 100644
--- a/src/include/pack_num.h
+++ b/src/include/pack_num.h
@@ -76,9 +76,9 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<N>(ops))>::type NextOpType;
 	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    typedef decltype(std::get<N>(ops).get(Getter<NEXT>::template getX<ETuple>( pos ))) ArgT;
+	    typedef decltype(std::get<N>(ops).get(getX<NEXT>( pos ))) ArgT;
 	    return PackNum<N-1>::template mkOpExpr<NEXT,ETuple,OpTuple,OpFunction,ArgT,Args...>
-		( f, pos, ops, std::get<N>(ops).get(Getter<NEXT>::template getX<ETuple>( pos )), args...);
+		( f, pos, ops, std::get<N>(ops).get(getX<NEXT>( pos )), args...);
 	}
 
 	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
@@ -87,9 +87,9 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<N>(ops))>::type NextOpType;
 	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    typedef decltype(std::get<N>(ops).template vget<V>(Getter<NEXT>::template getX<ETuple>( pos ))) ArgT;
+	    typedef decltype(std::get<N>(ops).template vget<V>(getX<NEXT>( pos ))) ArgT;
 	    return PackNum<N-1>::template mkVOpExpr<NEXT,V,ETuple,OpTuple,OpFunction,ArgT,Args...>
-		( f, pos, ops, std::get<N>(ops).template vget<V>(Getter<NEXT>::template getX<ETuple>( pos )), args...);
+		( f, pos, ops, std::get<N>(ops).template vget<V>(getX<NEXT>( pos )), args...);
 	}
 
 	template <class OpTuple, class Expr>
@@ -132,7 +132,7 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<N>(ot))>::type NextOpType;
 	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    std::get<N>( ot ).set( Getter<NEXT>::template getX<ETuple>( et ) );
+	    std::get<N>( ot ).set( getX<NEXT>( et ) );
 	    PackNum<N-1>::template setOpPos<NEXT,OpTuple,ETuple>(ot, et);
 	}
     };
@@ -174,9 +174,8 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
 	    static_assert(NEXT == 0, "inconsistent array positions");
-	    typedef decltype(std::get<0>(ops).get(Getter<0>::template getX<ETuple>( pos ))) ArgT;
-	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).get(Getter<0>::template getX<ETuple>( pos )), args...);
-	    //return OpFunction::apply(std::get<0>(ops).get(Getter<0>::template getX<ETuple>( pos )), args...);
+	    typedef decltype(std::get<0>(ops).get(getX<0>( pos ))) ArgT;
+	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).get(getX<0>( pos )), args...);
 	}
 
 	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
@@ -185,8 +184,8 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
 	    static_assert(NEXT == 0, "inconsistent array positions");
-	    typedef decltype(std::get<0>(ops).template vget<V>(Getter<0>::template getX<ETuple>( pos ))) ArgT;
-	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).template vget<V>(Getter<0>::template getX<ETuple>( pos )), args...);
+	    typedef decltype(std::get<0>(ops).template vget<V>(getX<0>( pos ))) ArgT;
+	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).template vget<V>(getX<0>( pos )), args...);
 	}
 
 	template <class OpTuple, class Expr>
@@ -229,7 +228,7 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<0>(ot))>::type NextOpType;
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
 	    static_assert(NEXT == 0, "inconsistent array positions");
-	    std::get<0>( ot ).set( Getter<NEXT>::template getX<ETuple>( et ) );
+	    std::get<0>( ot ).set( getX<NEXT>( et ) );
 	}
 
     };
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index a8c21a1..8176f9f 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -50,23 +50,12 @@ namespace MultiArrayTools
 	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	    //		  "this turns out to be a static endless loop");
 	    auto tmp = f(idxm);
-	    return sfor<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
-	}
-    };
-
-    template <size_t END, int OFF>
-    struct sfor<END,END,OFF>
-    {
-	template <typename Incr, typename F, typename Conc>
-	static inline auto exec(Incr incr, F f, Conc conc)
-	{
-	    return 0;
-	}
-
-	template <typename Incr, typename F, typename Create, typename... Args>
-	static inline auto unpack(Incr incr, F f, Create create, const Args&... args)
-	{
-	    return create(args...);
+	    if constexpr(BEG == END){
+		return create(args...);
+	    }
+	    else {
+		return sfor<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
+	    }
 	}
     };
 }
@@ -78,4 +67,6 @@ namespace MultiArrayTools
 #define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
 #define MA_CFOR(i,beg,end,incr,expr,cre) sfor<beg,end,0>::unpack([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
 
+#define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>::exec([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
+
 #endif
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index b6202c4..50b2229 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -6,43 +6,91 @@
 
 namespace MultiArrayHelper
 {
-
-    template <size_t I>
-    struct Getter
-    {
-	template <class ExtType>
-	static inline size_t get(const ExtType& et)
-	{
-	    return Getter<I-1>::get(et.next());
-	}
-
-	template <class ExtType>
-	static inline auto getX(const ExtType& et)
-	    -> decltype(Getter<I-1>::getX(et.next()))
-	{
-	    return Getter<I-1>::getX(et.next());
-	}	
-    };
-
-    template <>
-    struct Getter<0>
-    {
-	template <class ExtType>
-	static inline size_t get(const ExtType& et)
-	{
-	    return et.get();
-	}
-
-	template <class ExtType>
-	static inline auto getX(const ExtType& et)
-	    -> ExtType
-	{
-	    return et;
-	}	
-    };
-
+    
     struct None;
     
+    class ExtBase
+    {
+    public:
+	ExtBase() = default;
+	ExtBase(const ExtBase& in) = default;
+	ExtBase(ExtBase&& in) = default;
+	ExtBase& operator=(const ExtBase& in) = default;
+	ExtBase& operator=(ExtBase&& in) = default;
+        
+	virtual size_t size() const = 0;
+	virtual const size_t& val() const = 0;
+	//virtual size_t rootSteps() const = 0;
+	virtual bool operator==(const ExtBase& in) const = 0;
+	virtual bool operator==(size_t in) const = 0;
+	    
+	virtual std::shared_ptr<ExtBase> operator+(const ExtBase& in) const = 0;
+	virtual std::shared_ptr<ExtBase> operator*(size_t in) const = 0;
+	virtual void zero() = 0;
+
+	virtual std::shared_ptr<ExtBase> deepCopy() const = 0;
+	
+	template <class ExtType>
+	const ExtType& expl() const;
+
+        virtual std::string stype() const = 0;
+    };
+
+    typedef std::shared_ptr<ExtBase> DExt;
+
+    template <class ExtType>
+    class ExtT : public ExtBase
+    {
+    private:
+	ExtType mExt;
+    public:
+	static constexpr size_t SIZE = ExtType::SIZE;
+	static constexpr size_t NUM = ExtType::NUM;
+	
+	ExtT() = default;
+	ExtT(const ExtT& in) = default;
+	ExtT(ExtT&& in) = default;
+	ExtT& operator=(const ExtT& in) = default;
+	ExtT& operator=(ExtT&& in) = default;
+
+	ExtT(const ExtType& in) : mExt(in) {}
+
+	virtual std::shared_ptr<ExtBase> deepCopy() const override final { return std::make_shared<ExtT<ExtType>>(mExt); }
+
+	virtual size_t size() const override final { return sizeof(ExtType)/sizeof(size_t); }
+	//virtual size_t size() const override final { return ExtType::MExtSize(); }
+	//virtual size_t rootSteps() const override final;
+	const ExtType& ext() const { return mExt; }
+	virtual const size_t& val() const override final { return mExt.val(); }
+	virtual void zero() override final { mExt.zero(); }
+
+	virtual bool operator==(const ExtBase& in) const override final
+	{ return mExt == dynamic_cast<const ExtT<ExtType>&>(in).mExt; }
+	
+	virtual bool operator==(size_t in) const override final
+	{ return mExt == in; }
+
+	virtual DExt operator+(const ExtBase& in) const override final
+	{ return std::make_shared<ExtT<ExtType>>( mExt + dynamic_cast<const ExtT<ExtType>&>(in).mExt ); }
+	virtual DExt operator*(size_t in) const override final
+	{ return std::make_shared<ExtT<ExtType>>( mExt * in ); }
+
+        virtual std::string stype() const override final { return std::string("T[") + mExt.stype() + "]"; }
+    };
+    //class DExtT;
+
+    template <class ExtType>
+    DExt mkDExt(const ExtT<ExtType>& in)
+    {
+        return std::make_shared<ExtT<ExtType>>(in);
+    }
+
+    template <class ExtType>
+    ExtT<ExtType> mkExtT(const ExtType& in)
+    {
+        return ExtT<ExtType>(in);
+    }
+    
     template <class X>
     class MExt
     {
@@ -82,9 +130,7 @@ namespace MultiArrayHelper
 	inline const X& next() const;
 
         template <size_t N>
-        inline auto nn() const
-            -> decltype(Getter<N>::getX(*this))
-        { return Getter<N>::getX(*this); }
+        inline auto nn() const;
 
 	inline bool operator==(const MExt& in) const
 	{
@@ -194,9 +240,7 @@ namespace MultiArrayHelper
 	inline void zero();
 	
         template <size_t N>
-        inline auto nn() const
-            -> decltype(Getter<N>::getX(*this))
-        { return Getter<N>::getX(*this); }
+        inline auto nn() const;
         
 	inline MExt operator+(const MExt& in) const;
 	inline MExt operator+(const None& in) const;
@@ -210,7 +254,124 @@ namespace MultiArrayHelper
 
     };    
 
+    template <class X>
+    class DExtTX
+    {
+    private:
+	mutable DExt mDExt = nullptr;
+	X mNext;
 
+        template <class Y>
+        friend class DExtTX;
+    public:
+	static constexpr size_t NUM = X::SIZE;
+	static constexpr size_t SIZE = NUM + 1;
+	
+        DExtTX() { mDExt = std::make_shared<ExtT<None>>(); }
+        DExtTX(const DExtTX& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
+        DExtTX(DExtTX&& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
+        DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
+        DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
+        explicit DExtTX(const DExt& in) : mDExt(in) {}
+        /*
+	template <class Y>
+	DExtTX& operator=(const Y& y) { mDExt = std::make_shared<ExtT<Y>>(y); return *this; }
+
+	template <class Y>
+	DExtTX(const Y& y) : mDExt(std::make_shared<ExtT<Y>>(y)) {}
+        */
+	bool operator==(const DExtTX& in) const
+	{ return *mDExt == *in.mDExt and mNext == in.mNext; }
+	
+	bool operator==(size_t in) const
+	{ return *mDExt == in and mNext == in; }
+
+        template <class Y>
+        DExtTX(const DExtTX<Y>& in) : mDExt(in.mDExt), mNext(in.mNext) {}
+        
+	DExtTX(const DExt& y, const X& x) : mDExt(y->deepCopy()),
+                                            mNext(x) {}
+
+        virtual size_t size() const { return mDExt->size(); }
+        inline const DExt& get() const { return mDExt; }
+
+        inline DExtTX<None> reduce() const { return DExtTX<None>(mDExt,None(0)); }
+        
+        inline DExtTX operator+(const DExtTX& in) const
+        { if (not mDExt) return in; else return DExtTX( (*mDExt) + (*in.mDExt), mNext + in.mNext ); }
+        inline DExtTX operator*(size_t in) const
+        { if (not mDExt) return *this; else return DExtTX((*mDExt) * in, mNext * in); }
+
+	template <class ExtType>
+	inline const ExtType& expl() const
+	{ if(mDExt == nullptr) mDExt = std::make_shared<ExtT<ExtType>>(); assert(mDExt != nullptr); return mDExt->expl<ExtType>(); }
+
+	template <class Y>
+	inline auto extend(const Y& y) const -> DExtTX<decltype(mNext.extend(y))>
+	{ return DExtTX<decltype(mNext.extend(y))>(mDExt, mNext.extend(y)); }
+
+	inline const size_t& val() const { return mDExt->val(); }
+	inline const X& next() const { return mNext; }
+
+	inline void zero() { mDExt->zero(); }
+	
+	template <size_t N>
+	inline auto nn() const;
+
+        std::string stype() const { return std::string("D[") + mDExt->stype() + "," + mNext.stype() + "]"; }
+    };
+
+    typedef DExtTX<None> DExtT;
+    
+    inline MExt<None> mkExt(size_t s) { return MExt<None>(s); }
+
+
+    template <size_t I, class X>
+    auto getX(const MExt<X>& et)
+    {
+	if constexpr(I == 0){
+	    return et;
+	}
+	else {
+	    return getX<I-1>(et.next());
+	}
+    }
+
+    template <size_t I, class X>
+    auto getX(const DExtTX<X>& et)
+    {
+	if constexpr(I == 0){
+	    return et;
+	}
+	else {
+	    return getX<I-1>(et.next());
+	}
+    }
+
+    template <size_t I>
+    auto getX(const None& et)
+    {
+	static_assert(I == 0);
+	return et;
+    }
+
+    template <size_t I, class X>
+    size_t get(const MExt<X>& et)
+    {
+	return getX<I>(et).get();
+    }
+
+    template <size_t I, class X>
+    size_t get(const DExtTX<X>& et)
+    {
+	return getX<I>(et).get();
+    }
+
+    template <size_t I>
+    size_t get(const None& et)
+    {
+	return getX<I>(et).get();
+    }
 
 } // end namespace MultiArrayHelper
 
@@ -263,6 +424,13 @@ namespace MultiArrayHelper
 	mNext.zero();
     }
 
+    template <class X>
+    template <size_t N>
+    inline auto MExt<X>::nn() const
+    {
+	return getX<N>(*this);
+    }
+
     template <class X>
     inline MExt<X> MExt<X>::operator+(const MExt<X>& in) const
     {
@@ -312,6 +480,12 @@ namespace MultiArrayHelper
 	mExt = 0u;
     }
 
+    template <size_t N>
+    inline auto MExt<None>::nn() const
+    {
+	return getX<N>(*this);
+    }
+
     inline const size_t& MExt<None>::val() const
     {
 	return mExt;
@@ -334,6 +508,12 @@ namespace MultiArrayHelper
 	return MExt<None>(mExt * in);
     }
 
+    template <class X>
+    template <size_t N>
+    inline auto DExtTX<X>::nn() const
+    {
+	return getX<N>(*this);
+    }
 
 } // end namespace MultiArrayHelper
 
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 372c334..0b761b3 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -23,159 +23,7 @@ namespace MultiArrayHelper
 
     //typedef std::pair<size_t const*,size_t> DExt;
 
-    class ExtBase
-    {
-    public:
-	ExtBase() = default;
-	ExtBase(const ExtBase& in) = default;
-	ExtBase(ExtBase&& in) = default;
-	ExtBase& operator=(const ExtBase& in) = default;
-	ExtBase& operator=(ExtBase&& in) = default;
-        
-	virtual size_t size() const = 0;
-	virtual const size_t& val() const = 0;
-	//virtual size_t rootSteps() const = 0;
-	virtual bool operator==(const ExtBase& in) const = 0;
-	virtual bool operator==(size_t in) const = 0;
-	    
-	virtual std::shared_ptr<ExtBase> operator+(const ExtBase& in) const = 0;
-	virtual std::shared_ptr<ExtBase> operator*(size_t in) const = 0;
-	virtual void zero() = 0;
 
-	virtual std::shared_ptr<ExtBase> deepCopy() const = 0;
-	
-	template <class ExtType>
-	const ExtType& expl() const;
-
-        virtual std::string stype() const = 0;
-    };
-
-    typedef std::shared_ptr<ExtBase> DExt;
-
-    template <class ExtType>
-    class ExtT : public ExtBase
-    {
-    private:
-	ExtType mExt;
-    public:
-	static constexpr size_t SIZE = ExtType::SIZE;
-	static constexpr size_t NUM = ExtType::NUM;
-	
-	ExtT() = default;
-	ExtT(const ExtT& in) = default;
-	ExtT(ExtT&& in) = default;
-	ExtT& operator=(const ExtT& in) = default;
-	ExtT& operator=(ExtT&& in) = default;
-
-	ExtT(const ExtType& in) : mExt(in) {}
-
-	virtual std::shared_ptr<ExtBase> deepCopy() const override final { return std::make_shared<ExtT<ExtType>>(mExt); }
-
-	virtual size_t size() const override final { return sizeof(ExtType)/sizeof(size_t); }
-	//virtual size_t size() const override final { return ExtType::MExtSize(); }
-	//virtual size_t rootSteps() const override final;
-	const ExtType& ext() const { return mExt; }
-	virtual const size_t& val() const override final { return mExt.val(); }
-	virtual void zero() override final { mExt.zero(); }
-
-	virtual bool operator==(const ExtBase& in) const override final
-	{ return mExt == dynamic_cast<const ExtT<ExtType>&>(in).mExt; }
-	
-	virtual bool operator==(size_t in) const override final
-	{ return mExt == in; }
-
-	virtual DExt operator+(const ExtBase& in) const override final
-	{ return std::make_shared<ExtT<ExtType>>( mExt + dynamic_cast<const ExtT<ExtType>&>(in).mExt ); }
-	virtual DExt operator*(size_t in) const override final
-	{ return std::make_shared<ExtT<ExtType>>( mExt * in ); }
-
-        virtual std::string stype() const override final { return std::string("T[") + mExt.stype() + "]"; }
-    };
-    //class DExtT;
-
-    template <class ExtType>
-    DExt mkDExt(const ExtT<ExtType>& in)
-    {
-        return std::make_shared<ExtT<ExtType>>(in);
-    }
-
-    template <class ExtType>
-    ExtT<ExtType> mkExtT(const ExtType& in)
-    {
-        return ExtT<ExtType>(in);
-    }
-    
-    template <class X>
-    class DExtTX
-    {
-    private:
-	mutable DExt mDExt = nullptr;
-	X mNext;
-
-        template <class Y>
-        friend class DExtTX;
-    public:
-	static constexpr size_t NUM = X::SIZE;
-	static constexpr size_t SIZE = NUM + 1;
-	
-        DExtTX() { mDExt = std::make_shared<ExtT<None>>(); }
-        DExtTX(const DExtTX& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
-        DExtTX(DExtTX&& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
-        DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
-        DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
-        explicit DExtTX(const DExt& in) : mDExt(in) {}
-        /*
-	template <class Y>
-	DExtTX& operator=(const Y& y) { mDExt = std::make_shared<ExtT<Y>>(y); return *this; }
-
-	template <class Y>
-	DExtTX(const Y& y) : mDExt(std::make_shared<ExtT<Y>>(y)) {}
-        */
-	bool operator==(const DExtTX& in) const
-	{ return *mDExt == *in.mDExt and mNext == in.mNext; }
-	
-	bool operator==(size_t in) const
-	{ return *mDExt == in and mNext == in; }
-
-        template <class Y>
-        DExtTX(const DExtTX<Y>& in) : mDExt(in.mDExt), mNext(in.mNext) {}
-        
-	DExtTX(const DExt& y, const X& x) : mDExt(y->deepCopy()),
-                                            mNext(x) {}
-
-        virtual size_t size() const { return mDExt->size(); }
-        inline const DExt& get() const { return mDExt; }
-
-        inline DExtTX<None> reduce() const { return DExtTX<None>(mDExt,None(0)); }
-        
-        inline DExtTX operator+(const DExtTX& in) const
-        { if (not mDExt) return in; else return DExtTX( (*mDExt) + (*in.mDExt), mNext + in.mNext ); }
-        inline DExtTX operator*(size_t in) const
-        { if (not mDExt) return *this; else return DExtTX((*mDExt) * in, mNext * in); }
-
-	template <class ExtType>
-	inline const ExtType& expl() const
-	{ if(mDExt == nullptr) mDExt = std::make_shared<ExtT<ExtType>>(); assert(mDExt != nullptr); return mDExt->expl<ExtType>(); }
-
-	template <class Y>
-	inline auto extend(const Y& y) const -> DExtTX<decltype(mNext.extend(y))>
-	{ return DExtTX<decltype(mNext.extend(y))>(mDExt, mNext.extend(y)); }
-
-	inline const size_t& val() const { return mDExt->val(); }
-	inline const X& next() const { return mNext; }
-
-	inline void zero() { mDExt->zero(); }
-	
-	template <size_t N>
-	inline auto nn() const -> decltype(Getter<N>::getX(*this))
-	    { return Getter<N>::getX(*this); }
-
-        std::string stype() const { return std::string("D[") + mDExt->stype() + "," + mNext.stype() + "]"; }
-    };
-
-    typedef DExtTX<None> DExtT;
-    
-    inline MExt<None> mkExt(size_t s) { return MExt<None>(s); }
     
     class ExpressionBase
     {
@@ -1061,7 +909,7 @@ namespace MultiArrayHelper
         const size_t pos = (*mSubSet)[last.val()];
         const size_t mnpos = mlast;
         const ExtType npos = last + mExt*pos;
-        mExpr(mnpos, Getter<1>::template getX<ExtType>( npos ));
+        mExpr(mnpos, getX<1>( npos ));
     }
 
     template <class IndexClass, class Expr>
@@ -1072,7 +920,7 @@ namespace MultiArrayHelper
         const size_t pos = (*mSubSet)[last.val()];
         const size_t mnpos = mlast;
         const ExtType npos = last + mExt*pos;
-        mExpr(mnpos, Getter<1>::template getX<ExtType>( npos ));
+        mExpr(mnpos, getX<1>( npos ));
     }
     
     

From 9d85f8df46ac471339d00120475cffc4b9abbd57 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 11 Apr 2021 16:54:46 +0200
Subject: [PATCH 19/56] remove Application classes

---
 src/include/functional_multi_array.cc.h | 34 ++++++++-------------
 src/include/pack_num.h                  | 39 ++++++++-----------------
 2 files changed, 24 insertions(+), 49 deletions(-)

diff --git a/src/include/functional_multi_array.cc.h b/src/include/functional_multi_array.cc.h
index 1cced61..279cd5c 100644
--- a/src/include/functional_multi_array.cc.h
+++ b/src/include/functional_multi_array.cc.h
@@ -9,26 +9,6 @@ namespace MultiArrayTools
      *   FunctionalMultiArray   *	     
      ****************************/
 
-    template <bool FISSTATIC>
-    struct Application
-    {
-	template <typename T, class Function, typename Meta>
-	static inline T apply(const std::shared_ptr<Function>& f, const Meta& m)
-	{
-	    return (*f)(m);
-	}
-    };
-
-    template <>
-    struct Application<true>
-    {
-	template <typename T, class Function, typename Meta>
-	static inline T apply(const std::shared_ptr<Function>& f, const Meta& m)
-	{
-	    return Function::apply(m);
-	}
-    };
-	
     template <typename T, class Function, class... SRanges>
     FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges,
 								      const std::shared_ptr<Function>& func) :
@@ -51,14 +31,24 @@ namespace MultiArrayTools
     template <typename T, class Function, class... SRanges>
     const T& FunctionalMultiArray<T,Function,SRanges...>::operator[](const IndexType& i) const
     {
-	mVal = Application<Function::FISSTATIC>::template apply<T,Function,typename IndexType::MetaType>(mFunc, i.meta());
+	if constexpr(Function::FISSTATIC){
+	    mVal = Function::apply(i.meta());
+	}
+	else {
+	    mVal = (*mFunc)(i.meta());
+	}
 	return mVal;
     }
 
     template <typename T, class Function, class... SRanges>
     const T& FunctionalMultiArray<T,Function,SRanges...>::at(const typename CRange::IndexType::MetaType& meta) const
     {
-	mVal = Application<Function::FISSTATIC>::template apply<T,Function,typename IndexType::MetaType>(mFunc,meta);
+	if constexpr(Function::FISSTATIC){
+	    mVal = Function::apply(meta);
+	}
+	else {
+	    mVal = (*mFunc)(meta);
+	}
 	return mVal;
     }
 
diff --git a/src/include/pack_num.h b/src/include/pack_num.h
index 4f8c3b1..9a5613a 100644
--- a/src/include/pack_num.h
+++ b/src/include/pack_num.h
@@ -13,29 +13,6 @@
 
 namespace MultiArrayHelper
 {
-    template <bool ISSTATIC>
-    struct Application
-    {
-	template <class OpFunction, typename... Ts>
-	static inline auto apply(std::shared_ptr<OpFunction> f, Ts... as)
-	    -> decltype((*f)(as...))
-	{
-	    return (*f)(as...);
-	}
-    };
-
-    template <>
-    struct Application<true>
-    {
-	template <class OpFunction, typename... Ts>
-	static inline auto apply(std::shared_ptr<OpFunction> f, Ts... as)
-	    -> decltype(OpFunction::apply(as...))
-	{
-	    return OpFunction::apply(as...);
-	}
-    };
-    
-    
     template <size_t N>
     struct PackNum
     {
@@ -174,8 +151,12 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
 	    static_assert(NEXT == 0, "inconsistent array positions");
-	    typedef decltype(std::get<0>(ops).get(getX<0>( pos ))) ArgT;
-	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).get(getX<0>( pos )), args...);
+	    if constexpr(OpFunction::FISSTATIC){
+		return OpFunction::apply(std::get<0>(ops).get(getX<0>( pos )), args...);
+	    }
+	    else {
+		return (*f)(std::get<0>(ops).get(getX<0>( pos )), args...);
+	    }
 	}
 
 	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
@@ -184,8 +165,12 @@ namespace MultiArrayHelper
 	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
 	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
 	    static_assert(NEXT == 0, "inconsistent array positions");
-	    typedef decltype(std::get<0>(ops).template vget<V>(getX<0>( pos ))) ArgT;
-	    return Application<OpFunction::FISSTATIC>::template apply<OpFunction,ArgT,Args...>(f, std::get<0>(ops).template vget<V>(getX<0>( pos )), args...);
+	    if constexpr(OpFunction::FISSTATIC){
+		return OpFunction::apply(std::get<0>(ops).template vget<V>(getX<0>( pos )), args...);
+	    }
+	    else {
+		return (*f)(std::get<0>(ops).template vget<V>(getX<0>( pos )), args...);
+	    }
 	}
 
 	template <class OpTuple, class Expr>

From 44f6149a2331ef74024efd9d86384b673361ddbc Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 11 Apr 2021 22:11:20 +0200
Subject: [PATCH 20/56] rewrite Operation::get (not final solution)

---
 src/include/multi_array_operation.cc.h |  32 +++++++-
 src/include/multi_array_operation.h    |   6 ++
 src/include/statics/static_for.h       | 104 ++++++++++++-------------
 3 files changed, 85 insertions(+), 57 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 6c0644f..0c9f60b 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -1,5 +1,7 @@
 
 #include "multi_array_operation.h"
+#include "xfor/exttype.h"
+
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
@@ -978,16 +980,38 @@ namespace MultiArrayTools
 	mOps(ops...),
 	mF(ff)
     {
-	static_assert( not FISSTATIC, "using instance of function supposed to be static" );
+	static_assert( not FISSTATIC, "using instance of static function" );
     }
 
+    template <typename T, class OpFunction, class... Ops>
+    template <size_t I, size_t J, class ET>
+    inline auto Operation<T,OpFunction,Ops...>::getSubX(ET pos) const
+    {
+	// somehow get rid of the second condition (should NOT be needed if everything is correct)
+	if constexpr(I == J or sizeof...(Ops)-1 == I){
+	    return std::get<J>(mOps.mOps).get(pos);
+	}
+	else {
+	    typedef typename std::remove_reference<decltype(std::get<I>(mOps.mOps))>::type
+		NextOpType;
+	    return getSubX<I+1,J>(getX<NextOpType::SIZE>(pos));
+	}
+    } 
+    
     template <typename T, class OpFunction, class... Ops>
     template <class ET>
     inline auto Operation<T,OpFunction,Ops...>::get(ET pos) const
     {
-	typedef std::tuple<Ops...> OpTuple;
-	return PackNum<sizeof...(Ops)-1>::
-	    template mkOpExpr<SIZE,ET,OpTuple,OpFunction>(mF, pos, mOps.mOps);
+	auto cre = [&](auto... args)
+	{
+	    if constexpr(OpFunction::FISSTATIC){
+		return OpFunction::apply(args...);
+	    }
+	    else {
+		return (*mF)(args...);
+	    }
+	};
+	return MA_CFOR2(i,0,sizeof...(Ops),i+1,return getSub<i>(pos);,cre);
     }
 
     template <typename T, class OpFunction, class... Ops>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index fedbec5..1554ed1 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -803,6 +803,12 @@ namespace MultiArrayTools
 		
 	Operation(const Ops&... ops);
 	Operation(std::shared_ptr<OpFunction> ff, const Ops&... ops);
+
+	template <size_t I, size_t J, class ET>
+	inline auto getSubX(ET pos) const;
+
+	template <size_t J, class ET>
+	inline auto getSub(ET pos) const { return getSubX<0,J>(pos); }
 	
 	template <class ET>
 	inline auto get(ET pos) const;
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index 8176f9f..141f8eb 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -6,67 +6,65 @@
 
 namespace MultiArrayTools
 {
-
-    template <size_t BEG, size_t END, int OFF>
-    struct sfor
+    template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Conc>
+    inline auto sfor(Incr incr, F f, Conc conc)
     {
-	template <typename Incr, typename F, typename Conc>
-	static inline auto exec(Incr incr, F f, Conc conc)
-	{
-	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
-	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
-	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
-	    //		  "this turns out to be a static endless loop");
-	    auto tmp = f(idxm);
-	    if constexpr(incr(idx) == END){
-		return tmp;
-	    }
-	    else {
-		return conc(tmp, sfor<incr(idx),END,OFF>::exec(incr,f,conc));
-	    }
+	constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+	//		  "this turns out to be a static endless loop");
+	auto tmp = f(idxm);
+	if constexpr(incr(idx) == END){
+	    return tmp;
 	}
+	else {
+	    return conc(tmp, sfor<incr(idx),END,OFF>(incr,f,conc));
+	}
+    }
 
-	template <typename Incr, typename F, typename Conc, typename Arg>
-	static inline auto exec(Incr incr, F f, Conc conc, const Arg& arg)
-	{
-	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
-	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
-	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
-	    //		  "this turns out to be a static endless loop");
-	    auto tmp = f(idxm);
-	    if constexpr(incr(idx) == END){
-		return conc(tmp, arg);
-	    }
-	    else {
-		return conc(tmp, sfor<incr(idx),END,OFF>::exec(incr,f,conc,arg));
-	    }
+    template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Conc, typename Arg>
+    inline auto sfor(Incr incr, F f, Conc conc, const Arg& arg)
+    {
+	constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+	//		  "this turns out to be a static endless loop");
+	auto tmp = f(idxm);
+	if constexpr(incr(idx) == END){
+	    return conc(tmp, arg);
 	}
+	else {
+	    return conc(tmp, sfor<incr(idx),END,OFF>(incr,f,conc,arg));
+	}
+    }
 
-	template <typename Incr, typename F, typename Create, typename... Args>
-	static inline auto unpack(Incr incr, F f, Create create, const Args&... args)
-	{
-	    constexpr auto idx = std::integral_constant<size_t, BEG>{};
-	    constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
-	    //static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
-	    //		  "this turns out to be a static endless loop");
-	    auto tmp = f(idxm);
-	    if constexpr(BEG == END){
-		return create(args...);
-	    }
-	    else {
-		return sfor<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
-	    }
+    template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Create, typename... Args>
+    inline auto unpack(Incr incr, F f, Create create, const Args&... args)
+    {
+	constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
+	//		  "this turns out to be a static endless loop");
+	if constexpr(BEG == END){
+	    return create(args...);
 	}
-    };
+	else {
+	    auto tmp = f(idxm);
+	    return unpack<incr(idx),END,OFF>(incr, f, create, args..., tmp);
+	}
+    }
+
+    
 }
 
-#define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
-#define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
-#define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
-#define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
-#define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
-#define MA_CFOR(i,beg,end,incr,expr,cre) sfor<beg,end,0>::unpack([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
+#define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
+#define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
+#define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
+#define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
+#define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
+#define MA_CFOR(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
+#define MA_CFOR2(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, cre)
 
-#define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>::exec([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
+#define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
 
 #endif

From acda91d792b81e270f9903a01fa829f84fa3841f Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Tue, 4 May 2021 17:11:53 +0200
Subject: [PATCH 21/56] remove all PackNum stuff from multi_array_operation

---
 src/include/multi_array_operation.cc.h | 78 +++++++++++++++++---------
 src/include/multi_array_operation.h    | 44 ++++++++++++---
 src/include/statics/static_for.h       |  2 -
 3 files changed, 87 insertions(+), 37 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 0c9f60b..d1e417c 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -983,52 +983,74 @@ namespace MultiArrayTools
 	static_assert( not FISSTATIC, "using instance of static function" );
     }
 
-    template <typename T, class OpFunction, class... Ops>
-    template <size_t I, size_t J, class ET>
-    inline auto Operation<T,OpFunction,Ops...>::getSubX(ET pos) const
+    template <size_t I, class OpFunction, class ETuple, class OpTuple, typename... Args>
+    inline auto
+    mkOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, Args... args)
     {
-	// somehow get rid of the second condition (should NOT be needed if everything is correct)
-	if constexpr(I == J or sizeof...(Ops)-1 == I){
-	    return std::get<J>(mOps.mOps).get(pos);
-	}
-	else {
-	    typedef typename std::remove_reference<decltype(std::get<I>(mOps.mOps))>::type
-		NextOpType;
-	    return getSubX<I+1,J>(getX<NextOpType::SIZE>(pos));
-	}
-    } 
-    
-    template <typename T, class OpFunction, class... Ops>
-    template <class ET>
-    inline auto Operation<T,OpFunction,Ops...>::get(ET pos) const
-    {
-	auto cre = [&](auto... args)
-	{
+	if constexpr(I == std::tuple_size<OpTuple>{}){
 	    if constexpr(OpFunction::FISSTATIC){
 		return OpFunction::apply(args...);
 	    }
 	    else {
-		return (*mF)(args...);
+		(*f)(args...);
 	    }
-	};
-	return MA_CFOR2(i,0,sizeof...(Ops),i+1,return getSub<i>(pos);,cre);
+	}
+	else {
+	    typedef typename std::remove_reference<decltype(std::get<I>(ops))>::type NextOpType;
+	    return mkOpExpr<I+1>
+		( f, getX<NextOpType::SIZE>(pos), ops, args..., std::get<I>(ops).get(pos));
+	}
+    }
+
+    template <size_t I, typename V, class OpFunction, class ETuple, class OpTuple, typename... Args>
+    inline auto
+    mkVOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, Args... args)
+    {
+	if constexpr(I == std::tuple_size<OpTuple>{}){
+	    if constexpr(OpFunction::FISSTATIC){
+		return VFunc<OpFunction>::apply(args...);
+	    }
+	    else {
+		auto vf = mkVFuncPtr(f);
+		(*vf)(args...);
+	    }
+	}
+	else {
+	    typedef typename std::remove_reference<decltype(std::get<I>(ops))>::type NextOpType;
+	    return mkVOpExpr<I+1,V>( f, getX<NextOpType::SIZE>(pos), ops, args...,
+				     std::get<I>(ops).template vget<V>(pos));
+	}
+    }
+
+    template <typename T, class OpFunction, class... Ops>
+    template <class ET>
+    inline auto Operation<T,OpFunction,Ops...>::get(ET pos) const
+    {
+	return mkOpExpr<0>(mF, pos, mOps.mOps);
     }
 
     template <typename T, class OpFunction, class... Ops>
     template <typename V, class ET>
     inline auto Operation<T,OpFunction,Ops...>::vget(ET pos) const
     {
-	typedef std::tuple<Ops...> OpTuple;
-	return PackNum<sizeof...(Ops)-1>::
-	    template mkVOpExpr<SIZE,V,ET,OpTuple,VFunc<OpFunction>>(mkVFuncPtr(mF), pos, mOps.mOps); // implement!!!
+	return mkVOpExpr<0,V>(mF, pos, mOps.mOps);
     }
 
+    template <size_t I, class OpTuple, class ETuple>
+    static inline void setOpPos(OpTuple& ot, const ETuple& et)
+    {
+	if constexpr(I != std::tuple_size<OpTuple>{}){
+	    typedef typename std::remove_reference<decltype(std::get<I>(ot))>::type NextOpType;
+	    std::get<I>( ot ).set( et );
+	    setOpPos<I+1>(ot, getX<NextOpType::SIZE>(et));
+	}
+    }
+    
     template <typename T, class OpFunction, class... Ops>
     template <class ET>
     inline Operation<T,OpFunction,Ops...>& Operation<T,OpFunction,Ops...>::set(ET pos)
     {
-	typedef std::tuple<Ops...> OpTuple;
-	PackNum<sizeof...(Ops)-1>::template setOpPos<SIZE,OpTuple,ET>(mOps.mOps,pos);
+	setOpPos<0>(mOps.mOps,pos);
 	return *this;
     }
 
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 1554ed1..683b170 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -778,7 +778,43 @@ namespace MultiArrayTools
 
 	T const** data() const { assert(0); return nullptr; }
     };
-    
+
+    /*
+    template <typename T>
+    struct TFold
+    {
+	TFold() = default;
+	TFold(const TFold& in) = default;
+	TFold& operator=(const TFold& in) = default;
+	TFold(TFold&& in) = default;
+	TFold& operator=(TFold&& in) = default;
+	explicit TFold(const T v) : val(v) {}
+	
+	T val;
+	inline T& operator*() { return val; }
+	inline const T& operator*() const { return val; }
+    };
+
+    template <typename T1, typename T2>
+    inline std::tuple<TFold<T1>,TFold<T2>> operator,(const TFold<T1>& a1, const TFold<T2>& a2)
+    {
+	return std::make_tuple(a1,a2);
+    }
+
+    template <typename T1, typename T2...>
+    inline std::tuple<TFold<T1>,TFold<T2>> operator,(const TFold<T1>& a1,
+						     const std::tuple<TFold<T2>...>& a2)
+    {
+	return std::tuple_cat(std::make_tuple(a1),a2);
+    }
+
+    template <typename T2, typename T1...>
+    inline std::tuple<TFold<T1>,TFold<T2>> operator,(const std::tuple<TFold<T1>...>& a1,
+						     const TFold<T2>& a2)
+    {
+	return std::tuple_cat(a1,std::make_tuple(a2));
+    }
+    */
     template <typename T, class OpFunction, class... Ops>
     class Operation : public OperationTemplate<T,Operation<T,OpFunction,Ops...> >
     {
@@ -804,12 +840,6 @@ namespace MultiArrayTools
 	Operation(const Ops&... ops);
 	Operation(std::shared_ptr<OpFunction> ff, const Ops&... ops);
 
-	template <size_t I, size_t J, class ET>
-	inline auto getSubX(ET pos) const;
-
-	template <size_t J, class ET>
-	inline auto getSub(ET pos) const { return getSubX<0,J>(pos); }
-	
 	template <class ET>
 	inline auto get(ET pos) const;
 
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index 141f8eb..5fb77c9 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -53,7 +53,6 @@ namespace MultiArrayTools
 	    return unpack<incr(idx),END,OFF>(incr, f, create, args..., tmp);
 	}
     }
-
     
 }
 
@@ -63,7 +62,6 @@ namespace MultiArrayTools
 #define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
 #define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
 #define MA_CFOR(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
-#define MA_CFOR2(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, cre)
 
 #define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
 

From 7fee5aa45d1e852c31e448a3ab4378558a9f4215 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Tue, 4 May 2021 18:26:17 +0200
Subject: [PATCH 22/56] completely remove pack_num

---
 src/include/helper_tools.cc.h       |   3 +-
 src/include/helper_tools.h          |   1 -
 src/include/multi_array.cc.h        |  10 +-
 src/include/multi_array_operation.h |   1 -
 src/include/pack_num.h              | 225 ----------------------------
 src/include/slice.cc.h              |  15 +-
 src/include/slice.h                 |  14 +-
 src/include/statics/static_for.h    |   7 +-
 src/include/type_operations.h       |   5 +-
 9 files changed, 32 insertions(+), 249 deletions(-)
 delete mode 100644 src/include/pack_num.h

diff --git a/src/include/helper_tools.cc.h b/src/include/helper_tools.cc.h
index e7b6268..3e9b4b7 100644
--- a/src/include/helper_tools.cc.h
+++ b/src/include/helper_tools.cc.h
@@ -6,7 +6,8 @@ namespace MultiArrayTools
     template <typename... T>
     std::ostream& operator<<(std::ostream& out, const std::tuple<T...>& tp)
     {
-	PackNum<sizeof...(T)-1>::printTuple(out, tp);
+	MA_SFOR(i,0,sizeof...(T)-1,i+1, out << std::get<i>(tp) << ", ";);
+	out << std::get<sizeof...(T)-1>(tp);
 	return out;
     }
     
diff --git a/src/include/helper_tools.h b/src/include/helper_tools.h
index 77fac38..e8906df 100644
--- a/src/include/helper_tools.h
+++ b/src/include/helper_tools.h
@@ -5,7 +5,6 @@
 #include "base_def.h"
 #include "slice.h"
 #include <ostream>
-#include "pack_num.h"
 #include "map_range.h"
 #include <functional>
 #include "xfor/iloop.h"
diff --git a/src/include/multi_array.cc.h b/src/include/multi_array.cc.h
index bff9f42..130a038 100644
--- a/src/include/multi_array.cc.h
+++ b/src/include/multi_array.cc.h
@@ -1,5 +1,6 @@
 
 #include "multi_array.h"
+#include "statics/static_for.h"
 
 namespace MultiArrayTools
 {
@@ -246,11 +247,12 @@ namespace MultiArrayTools
 	    (*this) = in;
 	}
 	else {
-	    assert( PackNum<sizeof...(SRanges)-1>::checkIfSameInstance( MAB::mRange->space(), in.mRange->space() ) );
+	    MA_SCFOR2(i,0,sizeof...(SRanges),i+1,
+		      std::get<i>(MAB::mRange->space()).get() == std::get<i>(in.mRange->space()).get(),
+		      operator&&);
             for(size_t i = 0; i != mCont.size(); ++i){
                 mCont[i] += in.mCont[i];
             }
-	    //std::transform(mCont.begin(), mCont.end(), in.mCont.begin(), mCont.begin(), std::plus<T>());
 	}
 	return *this;
     }
@@ -262,7 +264,9 @@ namespace MultiArrayTools
 	    (*this) = in;
 	}
 	else {
-	    assert( PackNum<sizeof...(SRanges)-1>::checkIfSameInstance( MAB::mRange->space(), in.mRange->space() ) );
+	    MA_SCFOR2(i,0,sizeof...(SRanges),i+1,
+		      std::get<i>(MAB::mRange->space()).get() == std::get<i>(in.mRange->space()).get(),
+		      operator&&);
             for(size_t i = 0; i != mCont.size(); ++i){
                 mCont[i] -= in.mCont[i];
             }
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 683b170..2bbf4ca 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -14,7 +14,6 @@
 #include "mbase_def.h"
 
 #include "ranges/rheader.h"
-#include "pack_num.h"
 
 #include "arith.h"
 #include "xfor/xfor.h"
diff --git a/src/include/pack_num.h b/src/include/pack_num.h
deleted file mode 100644
index 9a5613a..0000000
--- a/src/include/pack_num.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// -*- C++ -*-
-
-#ifndef __pack_num_h__
-#define __pack_num_h__
-
-#include <cstdlib>
-//#include <type_traits>
-#include <tuple>
-#include <ostream>
-
-#include "base_def.h"
-#include "xfor/exttype.h"
-
-namespace MultiArrayHelper
-{
-    template <size_t N>
-    struct PackNum
-    {
-	template <class MA, class ITuple, class... IPtrs>
-	static auto mkElemOperation(const MA& ma, const ITuple& ituple, IPtrs... iptrs)
-	    -> decltype(PackNum<N-1>::mkElemOperation(ma, ituple, std::get<N>(ituple), iptrs...))
-	{
-	    return PackNum<N-1>::mkElemOperation(ma, ituple, std::get<N>(ituple), iptrs...);
-	}
-
-	
-	template <typename... T>
-	static void printTuple(std::ostream& out, const std::tuple<T...>& tp)
-	{
-	    out << std::get<sizeof...(T)-N-1>(tp) << ", ";
-	    PackNum<N-1>::printTuple(out, tp);
-	}
-
-	template <class... Ops>
-	static auto mkSteps(std::intptr_t ii, const std::tuple<Ops...>& otp)
-	    -> decltype(PackNum<N-1>::mkSteps(ii, otp).extend( std::get<N>(otp).rootSteps(ii)) )
-	{
-	    return PackNum<N-1>::mkSteps(ii, otp).extend( std::get<N>(otp).rootSteps(ii));
-	}
-	
-	template <class RootStepTuple, class IndexClass, class OpClass>
-	static void mkExt(std::array<RootStepTuple,IndexClass::totalDim()>& out,
-			  const std::array<std::intptr_t,IndexClass::totalDim()>& siar,
-			  const OpClass& second)
-	{
-	    std::get<N>(out) = second.rootSteps( std::get<N>(siar) );
-	    PackNum<N-1>::mkExt(out, siar, second);
-	}
-
-	template <size_t LAST, class ETuple, class OpTuple, class OpFunction, typename... Args>
-	static inline auto mkOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, Args... args)
-	{
-	    typedef typename std::remove_reference<decltype(std::get<N>(ops))>::type NextOpType;
-	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
-	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    typedef decltype(std::get<N>(ops).get(getX<NEXT>( pos ))) ArgT;
-	    return PackNum<N-1>::template mkOpExpr<NEXT,ETuple,OpTuple,OpFunction,ArgT,Args...>
-		( f, pos, ops, std::get<N>(ops).get(getX<NEXT>( pos )), args...);
-	}
-
-	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
-	static inline auto mkVOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, Args... args)
-	{
-	    typedef typename std::remove_reference<decltype(std::get<N>(ops))>::type NextOpType;
-	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
-	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    typedef decltype(std::get<N>(ops).template vget<V>(getX<NEXT>( pos ))) ArgT;
-	    return PackNum<N-1>::template mkVOpExpr<NEXT,V,ETuple,OpTuple,OpFunction,ArgT,Args...>
-		( f, pos, ops, std::get<N>(ops).template vget<V>(getX<NEXT>( pos )), args...);
-	}
-
-	template <class OpTuple, class Expr>
-	static auto mkLoop( const OpTuple& ot, Expr exp )
-	    -> decltype(std::get<N>(ot).loop( PackNum<N-1>::mkLoop(ot,exp) ))
-	{
-	    return std::get<N>(ot).loop( PackNum<N-1>::mkLoop(ot,exp) );
-	}
-
-	template <typename T, class Op, class... SRanges>
-	static void mkSliceBlocks(std::array<size_t, sizeof...(SRanges)+1>& blocks,
-				  const ContainerIndex<T,typename SRanges::IndexType...>& index,
-				  const Op& op, size_t total = 1)
-	{
-	    const size_t tmp = 
-		op.rootSteps(reinterpret_cast<std::intptr_t>
-			     ( index.template getPtr<N>().get() ) )
-		.val();
-	    std::get<N+1>(blocks) = tmp;
-	    PackNum<N-1>::template mkSliceBlocks<T,Op,SRanges...>(blocks, index, op, total * tmp);
-	}
-
-	template <class... SRanges>
-	static bool checkIfSameInstance(const std::tuple<std::shared_ptr<SRanges>...>& rtp1,
-					const std::tuple<std::shared_ptr<SRanges>...>& rtp2)
-	{
-	    return std::get<N>(rtp1).get() == std::get<N>(rtp2).get() and PackNum<N-1>::checkIfSameInstance(rtp1,rtp2);
-	}
-
-	template <class MA, class ITuple, class... Indices>
-	static inline auto mkMapOp(const MA& ma, const ITuple& itp, const std::shared_ptr<Indices>&... inds)
-	    -> decltype(PackNum<N-1>::mkMapOp(ma, itp, std::get<N>(itp), inds...))
-	{
-	    return PackNum<N-1>::mkMapOp(ma, itp, std::get<N>(itp), inds...);
-	}
-
-	template <size_t LAST,class OpTuple, class ETuple>
-	static inline void setOpPos(OpTuple& ot, const ETuple& et)
-	{
-	    typedef typename std::remove_reference<decltype(std::get<N>(ot))>::type NextOpType;
-	    static_assert(LAST >= NextOpType::SIZE, "inconsistent array positions");
-	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    std::get<N>( ot ).set( getX<NEXT>( et ) );
-	    PackNum<N-1>::template setOpPos<NEXT,OpTuple,ETuple>(ot, et);
-	}
-    };
-    
-    template<>
-    struct PackNum<0>
-    {
-	template <class MA, class ITuple, class... IPtrs>
-	static auto mkElemOperation(const MA& ma, const ITuple& ituple, IPtrs... iptrs)
-	    -> decltype(ma(iptrs...))
-	{
-	    return ma(iptrs...);
-	}
-	
-	template <typename... T>
-	static void printTuple(std::ostream& out, const std::tuple<T...>& tp)
-	{	    
-	    out << std::get<sizeof...(T)-1>(tp);
-	}
-
-	template <class... Ops>
-	static auto mkSteps(std::intptr_t ii, const std::tuple<Ops...>& otp)
-	    -> decltype(std::get<0>(otp).rootSteps(ii))
-	{
-	    return std::get<0>(otp).rootSteps(ii);
-	}
-
-	template <class RootStepTuple, class IndexClass, class OpClass>
-	static void mkExt(std::array<RootStepTuple,IndexClass::totalDim()>& out,
-			  const std::array<std::intptr_t,IndexClass::totalDim()>& siar,
-			  const OpClass& second)
-	{
-	    std::get<0>(out) = second.rootSteps( std::get<0>(siar) );
-	}
-	
-	template <size_t LAST, class ETuple, class OpTuple, class OpFunction, typename... Args>
-	static inline auto mkOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, const Args&... args)
-	{
-	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
-	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    static_assert(NEXT == 0, "inconsistent array positions");
-	    if constexpr(OpFunction::FISSTATIC){
-		return OpFunction::apply(std::get<0>(ops).get(getX<0>( pos )), args...);
-	    }
-	    else {
-		return (*f)(std::get<0>(ops).get(getX<0>( pos )), args...);
-	    }
-	}
-
-	template <size_t LAST, typename V, class ETuple, class OpTuple, class OpFunction, typename... Args>
-	static inline auto mkVOpExpr(std::shared_ptr<OpFunction> f, const ETuple& pos, const OpTuple& ops, const Args&... args)
-	{
-	    typedef typename std::remove_reference<decltype(std::get<0>(ops))>::type NextOpType;
-	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    static_assert(NEXT == 0, "inconsistent array positions");
-	    if constexpr(OpFunction::FISSTATIC){
-		return OpFunction::apply(std::get<0>(ops).template vget<V>(getX<0>( pos )), args...);
-	    }
-	    else {
-		return (*f)(std::get<0>(ops).template vget<V>(getX<0>( pos )), args...);
-	    }
-	}
-
-	template <class OpTuple, class Expr>
-	static auto mkLoop( const OpTuple& ot, Expr exp )
-	    -> decltype(std::get<0>(ot).loop( exp ))
-	{
-	    return std::get<0>(ot).loop( exp );
-	}
-
-	template <typename T, class Op, class... SRanges>
-	static void mkSliceBlocks(std::array<size_t, sizeof...(SRanges)+1>& blocks,
-				  const ContainerIndex<T,typename SRanges::IndexType...>& index,
-				  const Op& op, size_t total = 1)
-	{
-	    const size_t tmp = 
-		op.rootSteps(reinterpret_cast<std::intptr_t>
-			     ( index.template getPtr<0>().get() ) )
-		.val();
-	    std::get<1>(blocks) = tmp;
-	    std::get<0>(blocks) = total * tmp; // this is not correct, but not used so far ... !!!
-	}
-
-	template <class... SRanges>
-	static bool checkIfSameInstance(const std::tuple<std::shared_ptr<SRanges>...>& rtp1,
-					const std::tuple<std::shared_ptr<SRanges>...>& rtp2)
-	{
-	    return std::get<0>(rtp1).get() == std::get<0>(rtp2).get();
-	}
-
-	template <class MA, class ITuple, class... Indices>
-	static inline auto mkMapOp(const MA& ma, const ITuple& itp, const std::shared_ptr<Indices>&... inds)
-	    -> decltype(ma.exec(std::get<0>(itp), inds...))
-	{
-	    return ma.exec(std::get<0>(itp), inds...);
-	}
-
-	template <size_t LAST,class OpTuple, class ETuple>
-	static inline void setOpPos(OpTuple& ot, const ETuple& et)
-	{
-	    typedef typename std::remove_reference<decltype(std::get<0>(ot))>::type NextOpType;
-	    static constexpr size_t NEXT = LAST - NextOpType::SIZE;
-	    static_assert(NEXT == 0, "inconsistent array positions");
-	    std::get<0>( ot ).set( getX<NEXT>( et ) );
-	}
-
-    };
-
-
-    
-} // end namespace MultiArrayHelper
-
-#endif
diff --git a/src/include/slice.cc.h b/src/include/slice.cc.h
index 3d302f7..0505805 100644
--- a/src/include/slice.cc.h
+++ b/src/include/slice.cc.h
@@ -243,8 +243,9 @@ namespace MultiArrayTools
     SliceDef<T,SRanges...>& SliceDef<T,SRanges...>::operator=(const OperationRoot<T,ORanges...>& op)
     {
 	std::array<size_t,sizeof...(SRanges)+1> blocks;
-	PackNum<sizeof...(SRanges)-1>::
-	    template mkSliceBlocks<T,OperationRoot<T,ORanges...>,SRanges...>(blocks, mIndex, op);
+	MA_SFOR(i,0,sizeof...(SRanges),i+1,
+		std::get<i+1>(blocks) = op.rootSteps(reinterpret_cast<std::intptr_t>
+						   ( mIndex.template getPtr<i>().get())).val(););
 	mSl.format(blocks);
 	mSl.mData = op.data();
 	return *this;
@@ -264,8 +265,9 @@ namespace MultiArrayTools
     ConstSliceDef<T,SRanges...>& ConstSliceDef<T,SRanges...>::operator=(const ConstOperationRoot<T,ORanges...>& op)
     {
 	std::array<size_t,sizeof...(SRanges)+1> blocks;
-	PackNum<sizeof...(SRanges)-1>::
-	    template mkSliceBlocks<T,ConstOperationRoot<T,ORanges...>,SRanges...>(blocks, mIndex, op);
+	MA_SFOR(i,0,sizeof...(SRanges),i+1,
+		std::get<i+1>(blocks) = op.rootSteps(reinterpret_cast<std::intptr_t>
+						   ( mIndex.template getPtr<i>().get())).val(););
 	mSl.format(blocks);
 	mSl.mData = op.data();
 	return *this;
@@ -276,8 +278,9 @@ namespace MultiArrayTools
     ConstSliceDef<T,SRanges...>& ConstSliceDef<T,SRanges...>::operator=(const OperationRoot<T,ORanges...>& op)
     {
 	std::array<size_t,sizeof...(SRanges)+1> blocks;
-	PackNum<sizeof...(SRanges)-1>::
-	    template mkSliceBlocks<T,OperationRoot<T,ORanges...>,SRanges...>(blocks, mIndex, op);
+	MA_SFOR(i,0,sizeof...(SRanges),i+1,
+		std::get<i+1>(blocks) = op.rootSteps(reinterpret_cast<std::intptr_t>
+						   ( mIndex.template getPtr<i>().get())).val(););
 	mSl.format(blocks);
 	mSl.mData = op.data();
 	return *this;
diff --git a/src/include/slice.h b/src/include/slice.h
index bd79d83..886df4b 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -108,13 +108,13 @@ namespace MultiArrayTools
 
 	template <class Op>
 	static Slice<T,SRanges...> mkSlice( const typename Slice<T,SRanges...>::IndexType& ind,
-						 const Op& op )
+					    const Op& op )
 	{
 	    Slice<T,SRanges...> out(ind->range()->space(), &*ind);
 	    std::array<size_t,sizeof...(SRanges)+1> ff;
-	    for(size_t i = 0; i != sizeof...(SRanges)+1; ++i){
-		PackNum<sizeof...(SRanges)-1>::mkSliceBlocks(ff, ind, op);
-	    }
+	    MA_SFOR(i,0,sizeof...(SRanges),i+1,
+		std::get<i+1>(ff) = op.rootSteps(reinterpret_cast<std::intptr_t>
+						 ( ind.template getPtr<i>().get())).val(););
 	    out.format(ff);
 	    return out;
 	}
@@ -145,9 +145,9 @@ namespace MultiArrayTools
 	{
 	    ConstSlice<T,SRanges...> out(ind->range()->space(), &*ind);
 	    std::array<size_t,sizeof...(SRanges)+1> ff;
-	    for(size_t i = 0; i != sizeof...(SRanges)+1; ++i){
-		PackNum<sizeof...(SRanges)-1>::mkSliceBlocks(ff, ind, op);
-	    }
+	    MA_SFOR(i,0,sizeof...(SRanges),i+1,
+		std::get<i+1>(ff) = op.rootSteps(reinterpret_cast<std::intptr_t>
+						 ( ind.template getPtr<i>().get())).val(););
 	    out.format(ff);
 	    return out;
 	}
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index 5fb77c9..c89cc6f 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -14,7 +14,7 @@ namespace MultiArrayTools
 	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	//		  "this turns out to be a static endless loop");
 	auto tmp = f(idxm);
-	if constexpr(incr(idx) == END){
+	if constexpr(incr(idx) >= END){
 	    return tmp;
 	}
 	else {
@@ -30,7 +30,7 @@ namespace MultiArrayTools
 	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	//		  "this turns out to be a static endless loop");
 	auto tmp = f(idxm);
-	if constexpr(incr(idx) == END){
+	if constexpr(incr(idx) >= END){
 	    return conc(tmp, arg);
 	}
 	else {
@@ -45,7 +45,7 @@ namespace MultiArrayTools
 	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
 	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	//		  "this turns out to be a static endless loop");
-	if constexpr(BEG == END){
+	if constexpr(BEG >= END){
 	    return create(args...);
 	}
 	else {
@@ -58,6 +58,7 @@ namespace MultiArrayTools
 
 #define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
 #define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
+#define MA_SCFOR2(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto a, auto b) { return conc(a,b); })
 #define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
 #define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
 #define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index f38c243..3e13521 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -9,7 +9,8 @@
 #include "base_def.h"
 #include "mbase_def.h"
 
-#include "pack_num.h"
+#include "statics/static_for.h"
+
 #include <cmath>
 
 namespace MultiArrayTools
@@ -32,7 +33,7 @@ namespace MultiArrayTools
 	inline auto apply(const MultiArray<T,Ranges...>& ma)
 	    -> OperationRoot<T,Ranges...>
 	{
-	    return PackNum<sizeof...(Ranges)-1>::mkElemOperation(ma, ituple);
+	    return MA_CFOR(i,0,sizeof...(Ranges),i+1,return std::get<i>(ituple);,ma);
 	}
 
     private:

From 13488b9839589e169f07db9033dfa361d84af242 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 5 May 2021 20:04:13 +0200
Subject: [PATCH 23/56] ranges: start replacement of rpack_num

---
 src/include/ranges/multi_range.h  | 28 +++++++++++++++++++++++++---
 src/include/ranges/range_base.h   |  2 ++
 src/include/ranges/rpack_num.cc.h |  1 +
 3 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index f6f923c..2c359fd 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -17,6 +17,8 @@
 #include "ranges/x_to_string.h"
 #include "ranges/type_map.h"
 
+#include "statics/static_for.h"
+
 namespace MultiArrayTools
 {
     namespace
@@ -279,10 +281,30 @@ namespace MultiArrayTools
     MultiIndex<Indices...>::MultiIndex(const std::shared_ptr<MRange>& range) :
 	IndexInterface<MultiIndex<Indices...>,std::tuple<typename Indices::MetaType...> >(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<sizeof...(Indices),0,-1>
+	    ( [&](auto i) constexpr { return i-1; } ,
+	      [&](auto i) {
+		  auto r = range->template getPtr<i>();
+		  std::get<i>(mIPack) = r->beginPtr();
+		  *std::get<i>(mIPack) = 0;
+		  
+		  std::get<i>(mBlockSizes) = sfor<i,sizeof...(Indices),0>
+		      ( [&](auto j) { return j+1; } ,
+			[&](auto j) { return std::get<j>(mIPack)->max(); } ,
+			[&](auto a, auto b) { return a * b; }
+			);
+		  
+		  return 0;
+	      },
+	      [&](auto a, auto b) { return 0; }
+	     );
+	
+	IB::mPos = sfor<0,sizeof...(Indices),0>
+	    ( [&](auto i) {return i+1;},
+	      [&](auto i) {return std::get<i>(mIPack);},
+	      [&](auto a, auto b) {return a->pos() + b*a->max();},
+	      0 );
     }
 
     template <class... Indices>
diff --git a/src/include/ranges/range_base.h b/src/include/ranges/range_base.h
index dd2b421..8217797 100644
--- a/src/include/ranges/range_base.h
+++ b/src/include/ranges/range_base.h
@@ -116,6 +116,8 @@ namespace MultiArrayTools
 	
 	virtual Index begin() const = 0;
 	virtual Index end() const = 0;
+	std::shared_ptr<Index> beginPtr() const { return std::make_shared<Index>(this->begin()); }
+	std::shared_ptr<Index> endPtr() const { return std::make_shared<Index>(this->end()); }
 	virtual std::shared_ptr<IndexWrapperBase> aindex() const override final
         { return mkIndexWrapper(this->begin()); }
 	//{ auto i = std::make_shared<Index>(this->begin()); return std::make_shared<IndexWrapper<Index>>(i); } //!!!
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index 9d74c2c..48c8def 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -174,6 +174,7 @@ namespace MultiArrayHelper
 	    
         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);
     }
 

From 482a7a7b4e2eba2adcab467aa3c2389e7b0f93a4 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 6 May 2021 19:04:26 +0200
Subject: [PATCH 24/56] continue previous commit

---
 src/include/map_range.cc.h           |  31 +++--
 src/include/ranges/container_range.h | 198 ++++-----------------------
 src/include/ranges/dynamic_range.h   |   3 -
 src/include/ranges/index_base.h      |  10 +-
 src/include/ranges/multi_range.h     | 138 ++++++++-----------
 src/include/ranges/rpack_num.cc.h    | 130 ------------------
 src/include/ranges/rpack_num.h       |  90 ++++++------
 src/include/ranges/single_range.h    |  20 ---
 src/include/ranges/subrange.h        |  20 ---
 src/include/ranges/value_range.h     |  20 ---
 src/include/statics/static_for.h     |  89 +++++++++++-
 src/lib/ranges/dynamic_range.cc      |  17 ---
 12 files changed, 242 insertions(+), 524 deletions(-)

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 4495c58..0bcc18a 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -131,8 +131,16 @@ namespace MultiArrayTools
     GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::up()
     {
 	static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
-	IB::mPos += RPackNum<sizeof...(Indices)-DIR-1>::blockSize( mIPack );
-	RPackNum<DIR>::pp( mIPack );
+	IB::mPos += sfor_p<DIR,sizeof...(Indices)>
+	    ( [&](auto i) { return std::get<i>(mIPack)->max(); },
+	      [&](auto a, auto b) { return a * b; } );
+	sfor_m<DIR+1,0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.last() and i != 0) { si = 0; return true; }
+		else { ++si; return false; }
+		return false;
+	    } );
 	return *this;
     }
 
@@ -141,8 +149,16 @@ namespace MultiArrayTools
     GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::down()
     {
 	static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
-	IB::mPos -= RPackNum<sizeof...(Indices)-DIR-1>::blockSize( mIPack );
-	RPackNum<DIR>::mm( mIPack );
+	IB::mPos -= sfor_p<DIR,sizeof...(Indices)>
+	    ( [&](auto i) { return std::get<i>(mIPack)->max(); },
+	      [&](auto a, auto b) { return a * b; } );
+	sfor_m<DIR+1,0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.first() and i != 0) { si = si.max()-1; return true; }
+		else { --si; return false; }
+		return false;
+	    } );
 	return *this;
     }
     
@@ -185,14 +201,12 @@ namespace MultiArrayTools
     {
         (*mOutIndex) = pos;
 	IB::mPos = mOutIndex->pos();
-	//RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
 	return *this;
     }
 
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
     GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::operator++()
     {
-	//RPackNum<sizeof...(Indices)-1>::pp( mIPack );
 	++(*mOutIndex);
         IB::mPos = mOutIndex->pos();
 	return *this;
@@ -201,7 +215,6 @@ namespace MultiArrayTools
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
     GenMapIndex<OIType,Op,XSTYPE,Indices...>& GenMapIndex<OIType,Op,XSTYPE,Indices...>::operator--()
     {
-	//RPackNum<sizeof...(Indices)-1>::mm( mIPack );
         --(*mOutIndex);
         IB::mPos = mOutIndex->pos();
 	return *this;
@@ -210,20 +223,16 @@ namespace MultiArrayTools
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
     int GenMapIndex<OIType,Op,XSTYPE,Indices...>::pp(std::intptr_t idxPtrNum)
     {
-	//int tmp = RPackNum<sizeof...(Indices)-1>::pp(mIPack, mBlockSizes, idxPtrNum);
         mOutIndex->pp(idxPtrNum);
         IB::mPos = mOutIndex->pos();
-	//IB::mPos += tmp;
 	return 1;
     }
 
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
     int GenMapIndex<OIType,Op,XSTYPE,Indices...>::mm(std::intptr_t idxPtrNum)
     {
-	//int tmp = RPackNum<sizeof...(Indices)-1>::mm(mIPack, mBlockSizes, idxPtrNum);
         mOutIndex->mm(idxPtrNum);
         IB::mPos = mOutIndex->pos();
-	//IB::mPos -= tmp;
 	return 1;
     }
 
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index 435854f..d129cdb 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -68,12 +68,7 @@ namespace MultiArrayTools
 	    mCPos(in.mCPos),
 	    mObjPtrNum(in.mObjPtrNum)
 	{
-	    //if(copy){
 	    RPackNum<sizeof...(Indices)-1>::copyIndex(mIPack, in);
-		//}
-		//else {
-	    //mIPack = in.mIPack;
-		//}
 	}
 	
 	ContainerIndex& copy(const ContainerIndex& in)
@@ -149,16 +144,16 @@ namespace MultiArrayTools
 	void print(size_t offset);
 	
 	template <class Exprs>
-	auto ifor(size_t step, Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs));
+	auto ifor(size_t step, Exprs exs) const;
+	//-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs));
 
 	template <class Exprs>
-	auto iforh(size_t step, Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs));
+	auto iforh(size_t step, Exprs exs) const;
+	//  -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs));
 
         template <class Exprs>
-	auto pifor(size_t step, Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs));
+	auto pifor(size_t step, Exprs exs) const;
+	//  -> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs));
 
 	std::intptr_t container() const;
 	ContainerIndex& format(const std::array<size_t,sizeof...(Indices)+1>& blocks);
@@ -188,71 +183,6 @@ namespace MultiArrayTools
 	bool operator>=(const ContainerIndex& it) const;
 	
     };
-
-    /*
-    template <typename T, class... Ranges>
-    class ContainerRangeFactory : public RangeFactoryBase
-    {
-    public:
-
-	typedef ContainerRange<T,Ranges...> oType;
-	
-	ContainerRangeFactory();
-	ContainerRangeFactory(const std::shared_ptr<Ranges>&... rs);
-	ContainerRangeFactory(const typename ContainerRange<T,Ranges...>::SpaceType& space);
-	
-	virtual std::shared_ptr<RangeBase> create() override; 
-	
-    protected:
-	
-    };*/
-    /*
-    template <typename T, class... Ranges>
-    class ContainerRange : public RangeInterface<ContainerIndex<T,typename Ranges::IndexType...> >
-    {
-    public:
-
-	typedef RangeBase RB;
-	typedef std::tuple<std::shared_ptr<Ranges>...> SpaceType;
-	typedef ContainerIndex<T,typename Ranges::IndexType...> IndexType;
-	
-    protected:
-	ContainerRange() = default;
-	ContainerRange(const ContainerRange& in) = delete;
-	ContainerRange& operator=(const ContainerRange& in) = delete;
-	
-	ContainerRange(const std::shared_ptr<Ranges>&... rs);
-	ContainerRange(const SpaceType& space);
-
-	SpaceType mSpace;	
-
-    public:	
-	static const size_t sdim = sizeof...(Ranges);
-
-	virtual size_t dim() const override;
-	virtual size_t size() const override;
-
-	template <size_t N>
-	auto get() const -> decltype( *std::get<N>( mSpace ) )&;
-
-	template <size_t N>
-	auto getPtr() const -> decltype( std::get<N>( mSpace ) )&;
-
-	const SpaceType& space() const;
-	
-	virtual IndexType begin() const override;
-	virtual IndexType end() const override;
-
-	friend ContainerRangeFactory<T,Ranges...>;
-
-	static constexpr bool defaultable = false;
-	static constexpr size_t ISSTATIC = SubProp<Ranges...>::ISSTATIC;
-	static constexpr size_t SIZE = SubProp<Ranges...>::SIZE;
-    };
-    */
-
-    //template <typename T, class... Ranges>
-    //using ContainerRange = MultiRange<Ranges...>;
     
 } // end namespace MultiArrayTools
 
@@ -316,9 +246,6 @@ namespace MultiArrayTools
 	if(mExternControl){
 	    IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
 	    mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
-	    //VCHECK(id());
-	    //VCHECK(sizeof...(Indices));
-	    //assert(IB::mPos < IB::max());
 	}
 	return *this;
     }
@@ -368,7 +295,13 @@ namespace MultiArrayTools
 	if(mExternControl){
 	    IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
 	}
-	RPackNum<sizeof...(Indices)-1>::pp( mIPack );
+	sfor_m<sizeof...(Indices),0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.last() and i != 0) { si = 0; return true; }
+		else { ++si; return false; }
+		return false;
+	    } );
 	mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
 	++IB::mPos;
 	return *this;
@@ -380,7 +313,13 @@ namespace MultiArrayTools
 	if(mExternControl){
 	    IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
 	}
-	RPackNum<sizeof...(Indices)-1>::mm( mIPack );
+	sfor_m<sizeof...(Indices),0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.first() and i != 0) { si = si.max()-1; return true; }
+		else { --si; return false; }
+		return false;
+	    } );
 	mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
 	--IB::mPos;
 	return *this;
@@ -399,7 +338,7 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     int ContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
     {
-	int tmp = RPackNum<sizeof...(Indices)-1>::pp(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos += tmp;
 	return tmp;
     }
@@ -407,7 +346,7 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     int ContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
     {
-	int tmp = RPackNum<sizeof...(Indices)-1>::mm(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos -= tmp;
 	return tmp;
     }
@@ -503,7 +442,7 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     template <class Exprs>
     auto ContainerIndex<T,Indices...>::ifor(size_t step, Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs))
+    //	-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs))
     {
 	return RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs);
     }
@@ -511,7 +450,7 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     template <class Exprs>
     auto ContainerIndex<T,Indices...>::iforh(size_t step, Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs))
+    //	-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs))
     {
 	return RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs);
     }
@@ -519,7 +458,7 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     template <class Exprs>
     auto ContainerIndex<T,Indices...>::pifor(size_t step, Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs))
+    //	-> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs))
     {
 	return RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs);
     }
@@ -673,93 +612,6 @@ namespace MultiArrayTools
 	return IB::mPos >= it.pos();
     }
 
-    /*****************************
-     *   ContainerRangeFactory   *
-     *****************************/
-    /*
-    template <typename T, class... Ranges>
-    ContainerRangeFactory<T,Ranges...>::ContainerRangeFactory(const std::shared_ptr<Ranges>&... rs)
-    {
-	mProd = std::shared_ptr<ContainerRange<T,Ranges...> >( new ContainerRange<T,Ranges...>( rs... ) );
-    }
-   
-    template <typename T, class... Ranges>
-    ContainerRangeFactory<T,Ranges...>::
-    ContainerRangeFactory(const typename ContainerRange<T,Ranges...>::SpaceType& space)
-    {
-	mProd = std::shared_ptr<ContainerRange<T,Ranges...> >( new ContainerRange<T,Ranges...>( space ) );
-    }
-
-    template <typename T, class... Ranges>
-    std::shared_ptr<RangeBase> ContainerRangeFactory<T,Ranges...>::create()
-    {
-	setSelf();
-	return mProd;
-    }
-    */
-    /**********************
-     *   ContainerRange   *
-     **********************/
-    /*
-    template <typename T, class... Ranges>
-    ContainerRange<T,Ranges...>::ContainerRange(const std::shared_ptr<Ranges>&... rs) :
-	mSpace( std::make_tuple( rs... ) ) {}
-
-    template <typename T, class... Ranges>
-    ContainerRange<T,Ranges...>::ContainerRange(const SpaceType& space) : mSpace( space ) {}
-
-    template <typename T, class... Ranges>
-    size_t ContainerRange<T,Ranges...>::dim() const
-    {
-	return sizeof...(Ranges);
-    }
-
-    template <typename T, class... Ranges>
-    size_t ContainerRange<T,Ranges...>::size() const
-    {
-	return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
-    }
-
-    template <typename T, class... Ranges>
-    template <size_t N>
-    auto ContainerRange<T,Ranges...>::get() const -> decltype( *std::get<N>( mSpace ) )&
-    {
-	return *std::get<N>( mSpace );
-    }
-
-    template <typename T, class... Ranges>
-    template <size_t N>
-    auto ContainerRange<T,Ranges...>::getPtr() const -> decltype( std::get<N>( mSpace ) )&
-    {
-	return std::get<N>( mSpace );
-    }
-
-    template <typename T, class... Ranges>
-    const typename ContainerRange<T,Ranges...>::SpaceType& ContainerRange<T,Ranges...>::space() const
-    {
-	return mSpace;
-    }
-        
-    template <typename T, class... Ranges>
-    typename ContainerRange<T,Ranges...>::IndexType ContainerRange<T,Ranges...>::begin() const
-    {
-	ContainerIndex<T,typename Ranges::IndexType...>
-	    i( std::dynamic_pointer_cast<ContainerRange<T,Ranges...> >
-	       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
-	i = 0;
-	return i;
-    }
-
-    template <typename T, class... Ranges>
-    typename ContainerRange<T,Ranges...>::IndexType ContainerRange<T,Ranges...>::end() const
-    {
-	ContainerIndex<T,typename Ranges::IndexType...>
-	    i( std::dynamic_pointer_cast<ContainerRange<T,Ranges...> >
-	       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
-	i = size();
-	return i;
-    }
-    */
 } // end namespace MultiArrayTools
 
 
diff --git a/src/include/ranges/dynamic_range.h b/src/include/ranges/dynamic_range.h
index 7f7bd63..8431323 100644
--- a/src/include/ranges/dynamic_range.h
+++ b/src/include/ranges/dynamic_range.h
@@ -111,9 +111,6 @@ namespace MultiArrayTools
 
 	size_t getStepSize(size_t n) const;
         
-	std::string id() const;
-	void print(size_t offset);
-
 	template <class Expr>
 	DynamicExpression ifor(size_t step, Expr ex) const;
 
diff --git a/src/include/ranges/index_base.h b/src/include/ranges/index_base.h
index 6d22f15..550aa08 100644
--- a/src/include/ranges/index_base.h
+++ b/src/include/ranges/index_base.h
@@ -57,15 +57,11 @@ namespace MultiArrayTools
 	
 	operator size_t() const;
 
-	std::string id() const { return THIS().id(); }
-
 	std::string stringMeta() const { return THIS().stringMeta(); }
 	MetaType meta() const { return THIS().meta(); }
 	MetaType metaPtr() const { return THIS().metaPtr(); }
 	I& at(const MetaType& meta) { return THIS().at(meta); }
 
-	void print(size_t offset = 0) const { THIS().print(offset); }
-
 	// CHECK / IMPLEMENT !!!!!!
 	template <class Expr>
 	auto ifor(size_t step, const Expr ex) const
@@ -93,7 +89,6 @@ namespace MultiArrayTools
 	
 	std::shared_ptr<RangeBase> mRangePtr;
 	size_t mPos = 0;
-	size_t mId;
 	size_t mMax = 0;
 
 	std::intptr_t mPtrNum;
@@ -118,7 +113,7 @@ namespace MultiArrayTools
      **********************/
 
     template <class I, typename MetaType>
-    IndexInterface<I,MetaType>::IndexInterface() : mId(indexId())
+    IndexInterface<I,MetaType>::IndexInterface()
     {
 	mPtrNum = reinterpret_cast<std::intptr_t>(this);
     }
@@ -128,7 +123,6 @@ namespace MultiArrayTools
 									   mPos(in.mPos),
 									   mMax(in.mMax)
     {
-	mId = indexId();
 	mPtrNum = reinterpret_cast<std::intptr_t>(this);
     }
 
@@ -137,7 +131,6 @@ namespace MultiArrayTools
 								      mPos(in.mPos),
 								      mMax(in.mMax)
     {
-	mId = indexId();
 	mPtrNum = reinterpret_cast<std::intptr_t>(this);
     }
 
@@ -165,7 +158,6 @@ namespace MultiArrayTools
 							     mPos(pos),
 							     mMax(mRangePtr->size())
     {
-	mId = indexId();
 	mPtrNum = reinterpret_cast<std::intptr_t>(this);
     }
 
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 2c359fd..93739d3 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -115,21 +115,14 @@ namespace MultiArrayTools
 
 	size_t getStepSize(size_t n);
 
-	std::string id() const;
-	void print(size_t offset);
+	template <class Exprs>
+	auto ifor(size_t step, Exprs exs) const;
 
 	template <class Exprs>
-	auto ifor(size_t step, Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs));
-
-	template <class Exprs>
-	auto iforh(size_t step, Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs));
+	auto iforh(size_t step, Exprs exs) const;
 
         template <class Exprs>
-	auto pifor(size_t step, Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs));
-
+	auto pifor(size_t step, Exprs exs) const;
 
     };
 
@@ -173,7 +166,6 @@ namespace MultiArrayTools
         typedef std::tuple<typename Ranges::IndexType::MetaType...> MetaType;
 	typedef MultiRange RangeType;
 	typedef MultiRangeFactory<Ranges...> FType;
-	//typedef typename RangeInterface<MultiIndex<typename Ranges::IndexType...> >::IndexType IndexType;
 
     protected:
 	MultiRange() = delete;
@@ -249,30 +241,15 @@ namespace MultiArrayTools
      *   MultiIndex   *
      ******************/
 
-    /*
-    template <class... Indices>
-    MultiIndex<Indices...>::MultiIndex(const MultiIndex<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... Indices>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(const MultiIndex<Indices...>& in)
-    {
-	IndexI::operator=(in);
-	RPackNum<sizeof...(Indices)-1>::copy(mIPack, in);
-	IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
-	return *this;
-    }
-    */
     template <class... Indices>
     template <typename T>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(ContainerIndex<T,Indices...>& ci)
     {	
-	RPackNum<sizeof...(Indices)-1>::copyInst(mIPack, ci);
-	IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
+	sfor_p<0,sizeof...(Indices)>
+	    ( [&](auto i) { std::get<i>(mIPack) = ci.template getPtr<i>(); return true; } );
+	IB::mPos = sfor_p<0,sizeof...(Indices)>
+	    ( [&](auto i) { return std::get<i>(mIPack); },
+	      [&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
 	return *this;
     }
     
@@ -282,29 +259,21 @@ namespace MultiArrayTools
 	IndexInterface<MultiIndex<Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0)
     {
 	std::get<sizeof...(Indices)>(mBlockSizes) = 1;
-	sfor<sizeof...(Indices),0,-1>
-	    ( [&](auto i) constexpr { return i-1; } ,
-	      [&](auto i) {
+	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<i,sizeof...(Indices),0>
-		      ( [&](auto j) { return j+1; } ,
-			[&](auto j) { return std::get<j>(mIPack)->max(); } ,
-			[&](auto a, auto b) { return a * b; }
-			);
-		  
+		  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;
-	      },
-	      [&](auto a, auto b) { return 0; }
-	     );
+	      });
 	
-	IB::mPos = sfor<0,sizeof...(Indices),0>
-	    ( [&](auto i) {return i+1;},
-	      [&](auto i) {return std::get<i>(mIPack);},
-	      [&](auto a, auto b) {return a->pos() + b*a->max();},
-	      0 );
+	IB::mPos = sfor_p<0,sizeof...(Indices)>
+	    ( [&](auto i) { return std::get<i>(mIPack); },
+	      [&](auto a, auto b) {return a->pos() + b*a->max();}, 0 );
     }
 
     template <class... Indices>
@@ -312,8 +281,16 @@ namespace MultiArrayTools
     MultiIndex<Indices...>& MultiIndex<Indices...>::up()
     {
 	static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
-	IB::mPos += RPackNum<sizeof...(Indices)-DIR-1>::blockSize( mIPack );
-	RPackNum<DIR>::pp( mIPack );
+	IB::mPos += sfor_p<DIR,sizeof...(Indices)>
+	    ( [&](auto i) { return std::get<i>(mIPack)->max(); },
+	      [&](auto a, auto b) { return a * b; } );
+	sfor_m<DIR+1,0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.last() and i != 0) { si = 0; return true; }
+		else { ++si; return false; }
+		return false;
+	    } );
 	return *this;
     }
 
@@ -322,8 +299,16 @@ namespace MultiArrayTools
     MultiIndex<Indices...>& MultiIndex<Indices...>::down()
     {
 	static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
-	IB::mPos -= RPackNum<sizeof...(Indices)-DIR-1>::blockSize( mIPack );
-	RPackNum<DIR>::mm( mIPack );
+	IB::mPos -= sfor_p<DIR,sizeof...(Indices)>
+	    ( [&](auto i) { return std::get<i>(mIPack)->max(); },
+	      [&](auto a, auto b) { return a * b; } );
+	sfor_m<DIR+1,0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.first() and i != 0) { si = si.max()-1; return true; }
+		else { --si; return false; }
+		return false;
+	    } );
 	return *this;
     }
     
@@ -374,7 +359,13 @@ namespace MultiArrayTools
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator++()
     {
-	RPackNum<sizeof...(Indices)-1>::pp( mIPack );
+	sfor_m<sizeof...(Indices),0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.last() and i != 0) { si = 0; return true; }
+		else { ++si; return false; }
+		return false;
+	    } );
 	++IB::mPos;
 	return *this;
     }
@@ -382,15 +373,22 @@ namespace MultiArrayTools
     template <class... Indices>
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator--()
     {
-	RPackNum<sizeof...(Indices)-1>::mm( mIPack );
+	sfor_m<sizeof...(Indices),0>
+	    ( [&](auto i) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.first() and i != 0) { si = si.max()-1; return true; }
+		else { --si; return false; }
+		return false;
+	    } );
 	--IB::mPos;
 	return *this;
     }
 
+
     template <class... Indices>
     int MultiIndex<Indices...>::pp(std::intptr_t idxPtrNum)
     {
-	int tmp = RPackNum<sizeof...(Indices)-1>::pp(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos += tmp;
 	return tmp;
     }
@@ -398,7 +396,7 @@ namespace MultiArrayTools
     template <class... Indices>
     int MultiIndex<Indices...>::mm(std::intptr_t idxPtrNum)
     {
-	int tmp = RPackNum<sizeof...(Indices)-1>::mm(mIPack, mBlockSizes, idxPtrNum);
+	const int tmp = mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos -= tmp;
 	return tmp;
     }
@@ -421,7 +419,10 @@ namespace MultiArrayTools
     MultiIndex<Indices...>& MultiIndex<Indices...>::at(const MetaType& metaPos)
     {
 	RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
-	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 );
+	//IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
 	return *this;
     }
 
@@ -466,29 +467,10 @@ namespace MultiArrayTools
 	}
 	return mBlockSizes[n+1];
     }
-    
-    template <class... Indices>
-    std::string MultiIndex<Indices...>::id() const
-    {
-	return std::string("mul") + std::to_string(IB::mId);
-    }
-
-    template <class... Indices>
-    void MultiIndex<Indices...>::print(size_t offset)
-    {
-	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... Indices>
     template <class Exprs>
     auto MultiIndex<Indices...>::ifor(size_t step, Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs))
     {
 	return RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs);
     }
@@ -496,7 +478,6 @@ namespace MultiArrayTools
     template <class... Indices>
     template <class Exprs>
     auto MultiIndex<Indices...>::iforh(size_t step, Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs))
     {
 	return RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs);
     }
@@ -504,7 +485,6 @@ namespace MultiArrayTools
     template <class... Indices>
     template <class Exprs>
     auto MultiIndex<Indices...>::pifor(size_t step, Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs))
     {
 	return RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs);
     }
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index 48c8def..5a739d0 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -42,78 +42,6 @@ namespace MultiArrayHelper
         RPackNum<N-1>::initBlockSizes(bs, ip);
     }
 	
-    template <size_t N>
-    template <class... Indices>
-    inline void RPackNum<N>::pp(std::tuple<std::shared_ptr<Indices>...>& ip)
-    {
-        auto& si = *std::get<N>(ip);
-        if(si.last()){
-            si = 0;
-            RPackNum<N-1>::pp(ip);
-        }
-        else {
-            ++si;
-        }
-    }
-	
-    template <size_t N>
-    template <class... Indices>
-    inline int RPackNum<N>::pp(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                      std::array<size_t,sizeof...(Indices)+1>& bs,
-                                      std::intptr_t idxPtrNum)
-    {
-        auto& siPtr = std::get<N>(ip);
-        if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
-            return RPackNum<N-1>::pp(ip, bs, idxPtrNum);
-        }
-        else {
-            int tmp = siPtr->pp(idxPtrNum);
-            if(siPtr->pos() == siPtr->max()){
-                (*siPtr) = 0;
-                return RPackNum<N-1>::pp(ip, bs, idxPtrNum) - siPtr->max() + 1;
-            }
-            else {
-                return tmp * std::get<N+1>(bs);
-            }
-        }
-    }
-
-    template <size_t N>
-    template <class... Indices>
-    inline void RPackNum<N>::mm(std::tuple<std::shared_ptr<Indices>...>& ip)
-    {
-        auto& si = *std::get<N>(ip);
-        if(si.first()){
-            si = si.max() - 1;
-            RPackNum<N-1>::mm(ip);
-        }
-        else {
-            --si;
-        }
-    }
-	
-    // !!!!
-    template <size_t N>
-    template <class... Indices>
-    inline int RPackNum<N>::mm(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                      std::array<size_t,sizeof...(Indices)+1>& bs,
-                                      std::intptr_t idxPtrNum)
-    {
-        auto& siPtr = std::get<N>(ip);
-        if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
-            return std::get<N>(bs) + RPackNum<N-1>::mm(ip, bs, idxPtrNum);
-        }
-        else {
-            if(siPtr->first()){
-                (*siPtr) = siPtr->max() - 1;
-                return RPackNum<N-1>::mm(ip, bs, idxPtrNum) - siPtr->max() + 1;
-            }
-            else {
-                return siPtr->mm(idxPtrNum);
-            }
-        }
-    }
-	
     template <size_t N>
     template <class RangeTuple>
     size_t RPackNum<N>::getSize(const RangeTuple& rt)
@@ -256,14 +184,6 @@ namespace MultiArrayHelper
         RPackNum<N-1>::RangesToVec(rst, v);
     }
 
-    template <size_t N>
-    template <class... Indices>
-    void RPackNum<N>::printIndex(const std::tuple<std::shared_ptr<Indices>...>& ip, size_t offset)
-    {
-        std::get<N>(ip)->print(offset);
-        RPackNum<N-1>::printIndex(ip, offset);
-    }
-
     template <size_t N>
     template <class Range, class... Ranges>
     void RPackNum<N>::checkDefaultable()
@@ -423,50 +343,6 @@ namespace MultiArrayHelper
     {
         std::get<0>(bs) = RPackNum<sizeof...(Indices)>::blockSize(ip);
     }
-
-    template <class... Indices>
-    inline void RPackNum<0>::pp(std::tuple<std::shared_ptr<Indices>...>& ip)
-    {
-        auto& si = *std::get<0>(ip);
-        ++si;
-    }
-	
-    template <class... Indices>
-    inline int RPackNum<0>::pp(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                      std::array<size_t,sizeof...(Indices)+1>& bs,
-                                      std::intptr_t idxPtrNum)
-    {
-        auto& siPtr = std::get<0>(ip);
-        if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
-            return std::get<0>(bs);
-        }
-        else {
-            int tmp = siPtr->pp(idxPtrNum);
-            return tmp * std::get<1>(bs);
-        }
-    }
-
-    template <class... Indices>
-    inline void RPackNum<0>::mm(std::tuple<std::shared_ptr<Indices>...>& ip)
-    {
-        auto& si = *std::get<0>(ip);
-        --si;
-    }
-	
-    template <class... Indices>
-    inline int RPackNum<0>::mm(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                      std::array<size_t,sizeof...(Indices)+1>& bs,
-                                      std::intptr_t idxPtrNum)
-    {
-        auto& siPtr = std::get<0>(ip);
-        if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
-            return std::get<0>(bs);
-            //return 1;
-        }
-        else {
-            return siPtr->mm(idxPtrNum);
-        }
-    }
 	
     template <class RangeTuple>
     size_t RPackNum<0>::getSize(const RangeTuple& rt)
@@ -582,12 +458,6 @@ namespace MultiArrayHelper
         setRangeToVec(v, std::get<0>(rst));
     }
 
-    template <class... Indices>
-    void RPackNum<0>::printIndex(const std::tuple<std::shared_ptr<Indices>...>& ip, size_t offset)
-    {
-        std::get<0>(ip)->print(offset);
-    }
-
     template <class Range>
     void RPackNum<0>::checkDefaultable()
     {
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index 94b4083..b324688 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -13,6 +13,57 @@ 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();
@@ -54,23 +105,6 @@ namespace MultiArrayHelper
 	static void initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
 				   std::tuple<std::shared_ptr<Indices>...>& ip);
 	
-	template <class... Indices>
-	static inline void pp(std::tuple<std::shared_ptr<Indices>...>& ip);
-	
-	template <class... Indices>
-	static inline int pp(std::tuple<std::shared_ptr<Indices>...>& ip,
-			     std::array<size_t,sizeof...(Indices)+1>& bs,
-			     std::intptr_t idxPtrNum);
-
-	template <class... Indices>
-	static inline void mm(std::tuple<std::shared_ptr<Indices>...>& ip);
-	
-	// !!!!
-	template <class... Indices>
-	static inline int mm(std::tuple<std::shared_ptr<Indices>...>& ip,
-			     std::array<size_t,sizeof...(Indices)+1>& bs,
-			     std::intptr_t idxPtrNum);
-	
 	template <class RangeTuple>
 	static size_t getSize(const RangeTuple& rt);
 	
@@ -125,9 +159,6 @@ namespace MultiArrayHelper
 	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
 				       vector<std::intptr_t>& v);
 
-	template <class... Indices>
-	static void printIndex(const std::tuple<std::shared_ptr<Indices>...>& ip, size_t offset);
-
 	template <class Range, class... Ranges>
 	static void checkDefaultable();
 
@@ -195,22 +226,6 @@ namespace MultiArrayHelper
 	static void initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
 				   std::tuple<std::shared_ptr<Indices>...>& ip);
 
-	template <class... Indices>
-	static inline void pp(std::tuple<std::shared_ptr<Indices>...>& ip);
-	
-	template <class... Indices>
-	static inline int pp(std::tuple<std::shared_ptr<Indices>...>& ip,
-			     std::array<size_t,sizeof...(Indices)+1>& bs,
-			     std::intptr_t idxPtrNum);
-
-	template <class... Indices>
-	static inline void mm(std::tuple<std::shared_ptr<Indices>...>& ip);
-	
-	template <class... Indices>
-	static inline int mm(std::tuple<std::shared_ptr<Indices>...>& ip,
-			     std::array<size_t,sizeof...(Indices)+1>& bs,
-			     std::intptr_t idxPtrNum);
-	
 	template <class RangeTuple>
 	static size_t getSize(const RangeTuple& rt);
 	
@@ -263,9 +278,6 @@ namespace MultiArrayHelper
 	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
 				       vector<std::shared_ptr<RangeBase> >& v);
 
-	template <class... Indices>
-	static void printIndex(const std::tuple<std::shared_ptr<Indices>...>& ip, size_t offset);
-
 	template <class Range>
 	static void checkDefaultable();
 
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index 5a377eb..c413af8 100644
--- a/src/include/ranges/single_range.h
+++ b/src/include/ranges/single_range.h
@@ -78,9 +78,6 @@ namespace MultiArrayTools
 	void getPtr();
 
 	size_t getStepSize(size_t n);
-	
-	std::string id() const;
-	void print(size_t offset);
 
 	template <class Expr>
 	auto ifor(size_t step, Expr ex) const
@@ -492,23 +489,6 @@ namespace MultiArrayTools
 	return 1;
     }
 
-    template <typename U, SpaceType TYPE, size_t S>
-    std::string GenSingleIndex<U,TYPE,S>::id() const
-    {
-	return std::string("sin") + std::to_string(IB::mId);
-    }
-
-    template <typename U, SpaceType TYPE, size_t S>
-    void GenSingleIndex<U,TYPE,S>::print(size_t offset)
-    {
-	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;
-    }
-
     template <typename U, SpaceType TYPE, size_t S>
     template <class Expr>
     auto GenSingleIndex<U,TYPE,S>::ifor(size_t step, Expr ex) const
diff --git a/src/include/ranges/subrange.h b/src/include/ranges/subrange.h
index ecc4821..0fe2e6f 100644
--- a/src/include/ranges/subrange.h
+++ b/src/include/ranges/subrange.h
@@ -71,9 +71,6 @@ namespace MultiArrayTools
 
 	size_t getStepSize(size_t n);
 	
-	std::string id() const;
-	void print(size_t offset);
-
 	template <class Expr>
 	auto ifor(size_t step, Expr ex) const
 	    -> For<SubIndex<Index>,SubExpr<Index,Expr>>;
@@ -302,23 +299,6 @@ namespace MultiArrayTools
         return 1;
     }
 
-    template <class Index>
-    std::string SubIndex<Index>::id() const
-    {
-        return std::string("sub") + std::to_string(IB::mId);
-    }
-
-    template <class Index>
-    void SubIndex<Index>::print(size_t offset)
-    {
-	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;
-    }
-
     template <class Index>
     template <class Expr>
     auto SubIndex<Index>::ifor(size_t step, Expr ex) const
diff --git a/src/include/ranges/value_range.h b/src/include/ranges/value_range.h
index 537d202..e1e667c 100644
--- a/src/include/ranges/value_range.h
+++ b/src/include/ranges/value_range.h
@@ -69,9 +69,6 @@ namespace MultiArrayTools
 
 	size_t getStepSize(size_t n);
 	
-	std::string id() const;
-	void print(size_t offset);
-
 	template <class Expr>
 	auto ifor(size_t step, Expr ex) const
 	    -> For<ValueIndex<U>,Expr>;
@@ -275,23 +272,6 @@ namespace MultiArrayTools
 	return 1;
     }
 
-    template <typename U>
-    std::string ValueIndex<U>::id() const
-    {
-	return std::string("val") + std::to_string(IB::mId);
-    }
-
-    template <typename U>
-    void ValueIndex<U>::print(size_t offset)
-    {
-	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;
-    }
-
     template <typename U>
     template <class Expr>
     auto ValueIndex<U>::ifor(size_t step, Expr ex) const
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index c89cc6f..9b1ff31 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -6,6 +6,20 @@
 
 namespace MultiArrayTools
 {
+    template <size_t BEG, size_t END, int OFF, typename Incr, typename F>
+    inline void sfor(Incr incr, F f)
+    {
+	constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+
+	const bool cond = f(idxm);
+	if constexpr(incr(idx) != END){
+	    if(cond){
+		sfor<incr(idx),END,OFF>(incr,f);
+	    }
+	}
+    }
+    
     template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Conc>
     inline auto sfor(Incr incr, F f, Conc conc)
     {
@@ -14,7 +28,7 @@ namespace MultiArrayTools
 	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	//		  "this turns out to be a static endless loop");
 	auto tmp = f(idxm);
-	if constexpr(incr(idx) >= END){
+	if constexpr(incr(idx) == END){
 	    return tmp;
 	}
 	else {
@@ -30,7 +44,7 @@ namespace MultiArrayTools
 	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	//		  "this turns out to be a static endless loop");
 	auto tmp = f(idxm);
-	if constexpr(incr(idx) >= END){
+	if constexpr(incr(idx) == END){
 	    return conc(tmp, arg);
 	}
 	else {
@@ -45,7 +59,7 @@ namespace MultiArrayTools
 	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
 	//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
 	//		  "this turns out to be a static endless loop");
-	if constexpr(BEG >= END){
+	if constexpr(BEG == END){
 	    return create(args...);
 	}
 	else {
@@ -56,9 +70,78 @@ namespace MultiArrayTools
     
 }
 
+#define MA_INC [&](auto i) constexpr { return i+1; }
+#define MA_DEC [&](auto i) constexpr { return i-1; }
+#define MA_ZCONC [&](auto a, auto b) { return 0; }
+
+namespace MultiArrayTools
+{
+    template <size_t BEG, size_t END, typename F>
+    inline auto sfor_p(F f)
+    {
+	return sfor<BEG,END,0>(MA_INC,f);
+    }
+
+    template <size_t BEG, size_t END, typename F>
+    inline auto sfor_m(F f)
+    {
+	return sfor<BEG,END,-1>(MA_DEC,f);
+    }
+
+    template <size_t BEG, size_t END, typename F, typename Conc>
+    inline auto sfor_p(F f, Conc conc)
+    {
+	return sfor<BEG,END,0>(MA_INC,f,conc);
+    }
+
+    template <size_t BEG, size_t END, typename F>
+    inline auto sfor_pn(F f)
+    {
+	return sfor_p<BEG,END>(f,MA_ZCONC);
+    }
+    
+    template <size_t BEG, size_t END, typename F, typename Conc>
+    inline auto sfor_m(F f, Conc conc)
+    {
+	return sfor<BEG,END,-1>(MA_DEC,f,conc);
+    }
+
+    template <size_t BEG, size_t END, typename F>
+    inline auto sfor_mn(F f)
+    {
+	return sfor_m<BEG,END>(f,MA_ZCONC);
+    }
+
+    template <size_t BEG, size_t END, typename F, typename Conc, typename Arg>
+    inline auto sfor_p(F f, Conc conc, const Arg& arg)
+    {
+	return sfor<BEG,END,0>(MA_INC,f,conc,arg);
+    }
+
+    template <size_t BEG, size_t END, typename F, typename Arg>
+    inline auto sfor_pn(F f, const Arg& arg)
+    {
+	return sfor_p<BEG,END>(f,MA_ZCONC,arg);
+    }
+    
+    template <size_t BEG, size_t END, typename F, typename Conc, typename Arg>
+    inline auto sfor_m(F f, Conc conc, const Arg& arg)
+    {
+	return sfor<BEG,END,-1>(MA_DEC,f,conc,arg);
+    }
+
+    template <size_t BEG, size_t END, typename F, typename Arg>
+    inline auto sfor_mn(F f, const Arg& arg)
+    {
+	return sfor_m<BEG,END>(f,MA_ZCONC,arg);
+    }
+
+}
+
 #define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
 #define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
 #define MA_SCFOR2(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto a, auto b) { return conc(a,b); })
+#define MA_SCFOR3(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, conc)
 #define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
 #define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
 #define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
diff --git a/src/lib/ranges/dynamic_range.cc b/src/lib/ranges/dynamic_range.cc
index 7d2c641..6227486 100644
--- a/src/lib/ranges/dynamic_range.cc
+++ b/src/lib/ranges/dynamic_range.cc
@@ -303,23 +303,6 @@ namespace MultiArrayTools
 	return mIVec[n].second;
     }
 
-    
-    std::string DynamicIndex::id() const
-    {
-	return std::string("dyn") + std::to_string(IB::mId);
-    }
-
-        
-    void DynamicIndex::print(size_t offset)
-    {
-	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().first*/ << std::endl;
-    }
-
 
     /***********************
      *   DynamicRange    *

From 43e848635418c0a50b70d849873b5daf7dc13c16 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 7 May 2021 17:35:59 +0200
Subject: [PATCH 25/56] bugfix + continue prev com

---
 src/include/high_level_operation.cc.h | 118 ++++++++++----------------
 src/include/map_range.cc.h            |  83 ++++++------------
 src/include/map_range.h               |  20 +----
 src/include/ranges/container_range.h  |  56 ++++++++----
 src/include/ranges/multi_range.h      |  18 ++--
 src/include/ranges/rpack_num.cc.h     |  93 --------------------
 src/include/ranges/rpack_num.h        |  35 --------
 7 files changed, 126 insertions(+), 297 deletions(-)

diff --git a/src/include/high_level_operation.cc.h b/src/include/high_level_operation.cc.h
index db97d29..14643d7 100644
--- a/src/include/high_level_operation.cc.h
+++ b/src/include/high_level_operation.cc.h
@@ -114,82 +114,53 @@ 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
-                {
-                    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)
-                    {
-                        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>
-                                (res, in, inds..., op, ops..., dop, dops...);
-                        }
-                        else {
-                            auto op = inn->get();
-                            auto vop = inn->vget();
-                            typedef typename std::remove_reference<decltype(*op)>::type OP;
-                            typedef typename std::remove_reference<decltype(*vop)>::type VOP;
+	    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)
+		{
+		    //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;
+			res.appendOuter(dop);
+			assert(dop.op.init());
+			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();
+			}
+			else {
 			    if(op != nullptr){
 				res.op = mkDynOutOp(mkFOp<OpF>(*op,ops...), inds...);
 			    }
@@ -197,11 +168,12 @@ namespace MultiArrayTools
 				res.op = mkDynOutOp(mkFOp<OpF>(*vop,ops...), inds...);
 			    }
                             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;
     }
diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 0bcc18a..28f902d 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -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>
diff --git a/src/include/map_range.h b/src/include/map_range.h
index 1181a70..6bd6e4d 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -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
-	    -> 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 ifor(size_t step, Exprs exs) const; // first step arg not used!
 
         template <class Exprs>
-	auto pifor(size_t step, Exprs exs) const
-	    -> decltype(ifor(step, exs)); // NO MULTITHREADING
-
+	auto pifor(size_t step, Exprs exs) const; // 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;
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index d129cdb..a32898b 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -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;
     }
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 93739d3..8f05d2a 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -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;
     }
 
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index 5a739d0..b8bbeb0 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -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)
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index b324688..e37b759 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -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);

From 29f4ddc0cd9735f9278fec56466974c93ee94a1f Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 12 May 2021 17:56:35 +0200
Subject: [PATCH 26/56] continue...

---
 src/include/map_range.cc.h           |  2 +-
 src/include/ranges/container_range.h | 20 ++++++-
 src/include/ranges/multi_range.h     | 11 +++-
 src/include/ranges/range_helper.h    | 23 +++++++
 src/include/ranges/rpack_num.cc.h    | 90 ----------------------------
 src/include/ranges/rpack_num.h       | 34 -----------
 src/include/statics/static_for.h     | 33 +++++++++-
 7 files changed, 81 insertions(+), 132 deletions(-)
 create mode 100644 src/include/ranges/range_helper.h

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 28f902d..87f8076 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -187,7 +187,7 @@ namespace MultiArrayTools
 	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);
+	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, IB::mPos);
 	return *this;
     }
 
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index a32898b..34d0b3c 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -68,7 +68,14 @@ namespace MultiArrayTools
 	    mCPos(in.mCPos),
 	    mObjPtrNum(in.mObjPtrNum)
 	{
-	    RPackNum<sizeof...(Indices)-1>::copyIndex(mIPack, in);
+	    sfor_pn<0,sizeof...(Indices)>
+		( [&](auto i)
+		{
+		    typedef typename std::remove_reference<decltype(*std::get<i>(mIPack))>::type
+			SubType;
+		    std::get<i>(mIPack) = std::make_shared<SubType>( in.template get<i>() ) ;
+		    return true;
+		});
 	}
 	
 	ContainerIndex& copy(const ContainerIndex& in)
@@ -80,7 +87,14 @@ namespace MultiArrayTools
 	    mData = in.mData;
 	    mCPos = in.mCPos;
 	    mObjPtrNum = in.mObjPtrNum;
-	    RPackNum<sizeof...(Indices)-1>::copyIndex(mIPack, in);
+	    sfor_pn<0,sizeof...(Indices)>
+		( [&](auto i)
+		{
+		    typedef typename std::remove_reference<decltype(*std::get<i>(mIPack))>::type
+			SubType;
+		    std::get<i>(mIPack) = std::make_shared<SubType>( in.template get<i>() ) ;
+		    return true;
+		});
 	    return *this;
 	}
 	
@@ -354,7 +368,7 @@ namespace MultiArrayTools
     ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator=(size_t pos)
     {
 	IB::mPos = pos;
-	RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
+	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, pos);
 	mCPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
 	return *this;
     }
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 8f05d2a..02a4cfe 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -13,6 +13,7 @@
 #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"
 #include "ranges/type_map.h"
@@ -337,7 +338,7 @@ namespace MultiArrayTools
     {
 	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);
+	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, IB::mPos);
 	return *this;
     }
 
@@ -351,7 +352,7 @@ namespace MultiArrayTools
     MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(size_t pos)
     {
 	IB::mPos = pos;
-	RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
+	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, pos);
 	return *this;
     }
 
@@ -576,7 +577,11 @@ namespace MultiArrayTools
     template <class... Indices>
     std::shared_ptr<RangeBase> MultiRange<Indices...>::sub(size_t num) const
     {
-	return RPackNum<sizeof...(Indices)-1>::getSub(mSpace, num);
+	assert(num < sizeof...(Indices));
+	return sforx_p<0,sizeof...(Indices)>
+	    ( [&](auto i) { return std::dynamic_pointer_cast<RangeBase>(std::get<i>(mSpace)); },
+	      [&](auto i) { return num != i;} );
+	//return RPackNum<sizeof...(Indices)-1>::getSub(mSpace, num);
     }
 
     template <class... Ranges>
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
new file mode 100644
index 0000000..88d2c3a
--- /dev/null
+++ b/src/include/ranges/range_helper.h
@@ -0,0 +1,23 @@
+
+#ifndef __range_helper_h__
+#define __range_helper_h__
+
+namespace MultiArrayTools
+{
+    namespace RangeHelper
+    {
+	template <size_t N, class IndexPack>
+	void setIndexPack(IndexPack& iPack, size_t pos)
+	{
+	    auto& i = *std::get<N>(iPack).get();
+	    const size_t ownPos = pos % i.max();
+	    i = ownPos;
+	    if constexpr(N != 0){
+		setIndexPack<N-1>(iPack, (pos - ownPos) / i.max() );
+	    }
+	}
+	
+    } // namespace RangeHelper
+} // namespace MultiArrayTools
+
+#endif
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index b8bbeb0..600943c 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -40,47 +40,6 @@ namespace MultiArrayHelper
         return std::get<N>(rt)->size() * RPackNum<N-1>::getSize(rt);
     }
 	
-    template <size_t N>
-    template <class SpaceClass>
-    inline std::shared_ptr<RangeBase> RPackNum<N>::getSub(const SpaceClass& space, size_t num)
-    {
-        if(num == N){
-            return std::get<N>(space);
-        }
-        else {
-            return RPackNum<N-1>::getSub(space, num);
-        }
-    }
-
-    template <size_t N>
-    template <class IndexPack>
-    void RPackNum<N>::setIndexPack(IndexPack& iPack, size_t pos)
-    {
-        auto& i = *std::get<N>(iPack).get();
-        const size_t ownPos = pos % i.max(); 
-        i = ownPos;
-        RPackNum<N-1>::setIndexPack(iPack, (pos - ownPos) / i.max() );
-    }
-	
-    template <size_t N>
-    template <class IndexType, class... Indices>
-    void RPackNum<N>::copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                      const IndexType& ind)
-    {
-        std::get<N>(ip) = ind.template getPtr<N>() ;
-        RPackNum<N-1>::copyInst(ip, ind);
-    }
-
-    template <size_t N>
-    template <class IndexType, class... Indices>
-    void RPackNum<N>::copyIndex(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                       const IndexType& ind)
-    {
-        typedef typename std::remove_reference<decltype(*std::get<N>(ip))>::type SubType;
-        std::get<N>(ip) = std::make_shared<SubType>( ind.template get<N>() ) ;
-        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,
@@ -132,14 +91,6 @@ namespace MultiArrayHelper
         RPackNum<N-1>::RangesToVec(rst, v);
     }
 
-    template <size_t N>
-    template <class Range, class... Ranges>
-    void RPackNum<N>::checkDefaultable()
-    {
-        static_assert( Range::defaultable, "not defaultable" );
-        RPackNum<N-1>::template checkDefaultable<Ranges...>();
-    }
-
     template <size_t N>
     template <class IndexPack, class BlockArray, class Exprs>
     auto RPackNum<N>::mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
@@ -291,41 +242,6 @@ namespace MultiArrayHelper
         return std::get<0>(rt)->size();
     }
 	
-    template <class SpaceClass>
-    inline std::shared_ptr<RangeBase> RPackNum<0>::getSub(const SpaceClass& space, size_t num)
-    {
-        if(num == 0){
-            return std::get<0>(space);
-        }
-        else {
-            assert(0);
-            return std::shared_ptr<RangeBase>();
-        }
-    }
-
-    template <class IndexPack>
-    void RPackNum<0>::setIndexPack(IndexPack& iPack, size_t pos)
-    {
-        auto& i = *std::get<0>(iPack);
-        const size_t ownPos = pos % i.max(); 
-        i = ownPos;
-    }
-	
-    template <class IndexType, class... Indices>
-    void RPackNum<0>::copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                      const IndexType& ind)
-    {
-        std::get<0>(ip) = ind.template getPtr<0>();
-    }
-
-    template <class IndexType, class... Indices>
-    void RPackNum<0>::copyIndex(std::tuple<std::shared_ptr<Indices>...>& ip,
-                                       const IndexType& ind)
-    {
-        typedef typename std::remove_reference<decltype(*std::get<0>(ip))>::type SubType;
-        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,
                                               const std::array<size_t,sizeof...(Indices)+1>& blockSize)
@@ -365,12 +281,6 @@ namespace MultiArrayHelper
         setRangeToVec(v, std::get<0>(rst));
     }
 
-    template <class Range>
-    void RPackNum<0>::checkDefaultable()
-    {
-        static_assert( Range::defaultable, "not defaultable" );
-    }
-
     template <class IndexPack, class BlockArray, class Exprs>
     auto RPackNum<0>::mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
         -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index e37b759..4ef41ef 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -105,20 +105,6 @@ namespace MultiArrayHelper
 	template <class RangeTuple>
 	static size_t getSize(const RangeTuple& rt);
 	
-	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 IndexType, class... Indices>
-	static void copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
-			     const IndexType& ind);
-
-	template <class IndexType, class... Indices>
-	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,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize);
@@ -142,9 +128,6 @@ namespace MultiArrayHelper
 	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
 				       vector<std::intptr_t>& v);
 
-	template <class Range, class... Ranges>
-	static void checkDefaultable();
-
 	template <class IndexPack, class BlockArray, class Exprs>
 	static auto mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
 	    -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
@@ -208,20 +191,6 @@ namespace MultiArrayHelper
 	template <class RangeTuple>
 	static size_t getSize(const RangeTuple& rt);
 	
-	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 IndexType, class... Indices>
-	static void copyInst(std::tuple<std::shared_ptr<Indices>...>& ip,
-			     const IndexType& ind);
-
-	template <class IndexType, class... Indices>
-	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,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize);
@@ -243,9 +212,6 @@ namespace MultiArrayHelper
 	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
 				       vector<std::shared_ptr<RangeBase> >& v);
 
-	template <class Range>
-	static void checkDefaultable();
-
 	template <class IndexPack, class BlockArray, class Exprs>
 	static auto mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
 	    -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index 9b1ff31..77d393a 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -19,7 +19,26 @@ namespace MultiArrayTools
 	    }
 	}
     }
-    
+
+    template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Cond>
+    inline auto sforx(Incr incr, F f, Cond cond)
+    {
+	constexpr auto idx = std::integral_constant<size_t, BEG>{};
+	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
+
+	if constexpr(incr(idx) != END){
+	    if(cond(idx)){
+		return sforx<incr(idx),END,OFF>(incr,f,cond);
+	    }
+	    else {
+		return f(idxm);
+	    }
+	}
+	else {
+	    return f(idxm);
+	}
+    }
+
     template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Conc>
     inline auto sfor(Incr incr, F f, Conc conc)
     {
@@ -88,6 +107,18 @@ namespace MultiArrayTools
 	return sfor<BEG,END,-1>(MA_DEC,f);
     }
 
+    template <size_t BEG, size_t END, typename F, typename Cond>
+    inline auto sforx_p(F f, Cond cond)
+    {
+	return sforx<BEG,END,0>(MA_INC,f,cond);
+    }
+
+    template <size_t BEG, size_t END, typename F, typename Cond>
+    inline auto sforx_m(F f, Cond cond)
+    {
+	return sforx<BEG,END,-1>(MA_DEC,f,cond);
+    }
+
     template <size_t BEG, size_t END, typename F, typename Conc>
     inline auto sfor_p(F f, Conc conc)
     {

From 893b2360bc97c31f4c8ae2772b2ce4b9737c6081 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 27 May 2021 11:02:36 +0200
Subject: [PATCH 27/56] remove rpacknum getMeta, getSize, getTypeNum

---
 src/include/map_range.cc.h            |  2 +-
 src/include/ranges/anonymous_range.h  |  8 +++--
 src/include/ranges/dynamic_range.cc.h |  8 +++--
 src/include/ranges/multi_range.h      |  9 +++--
 src/include/ranges/range_helper.h     | 24 ++++++++++++++
 src/include/ranges/rpack_num.cc.h     | 47 ---------------------------
 src/include/ranges/rpack_num.h        | 18 ----------
 src/include/xfor/exttype.h            |  5 +--
 8 files changed, 46 insertions(+), 75 deletions(-)

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 87f8076..fcb2a49 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -591,7 +591,7 @@ namespace MultiArrayTools
     vector<size_t> GenMapRange<ORType,Op,XSTYPE,Ranges...>::typeNum() const
     {
         vector<size_t> o;
-        RPackNum<sizeof...(Ranges)-1>::getTypeNum(o,mSpace);
+	RangeHelper::getTypeNum<sizeof...(Ranges)-1>(o,mSpace);
         return o;
     }
 
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index f8ee5b9..48a5a00 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/src/include/ranges/anonymous_range.h
@@ -213,7 +213,9 @@ namespace MultiArrayTools
 	RangeInterface<AnonymousIndex>()
     {
 	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
-	mSize = RPackNum<sizeof...(RangeTypes)-1>::getSize( origs );
+	mSize = sfor_p<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { return std::get<i>(origs)->size(); },
+	      [&](auto a, auto b) { return a * b; } );
 	if(sizeof...(RangeTypes)){
 	    mEmpty = false;
 	}
@@ -225,7 +227,9 @@ namespace MultiArrayTools
     {
 	auto rst = std::make_tuple(origs...);
 	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( rst, mOrig );
-	mSize = RPackNum<sizeof...(RangeTypes)-1>::getSize( rst );
+	mSize = sfor_p<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { return std::get<i>(rst)->size(); },
+	      [&](auto a, auto b) { return a * b; } );
 	if(sizeof...(RangeTypes)){
 	    mEmpty = false;
 	}
diff --git a/src/include/ranges/dynamic_range.cc.h b/src/include/ranges/dynamic_range.cc.h
index de305cd..e5ae01f 100644
--- a/src/include/ranges/dynamic_range.cc.h
+++ b/src/include/ranges/dynamic_range.cc.h
@@ -144,7 +144,9 @@ namespace MultiArrayTools
 	RangeInterface<DynamicIndex>()
     {
 	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
-	mSize = RPackNum<sizeof...(RangeTypes)-1>::getSize( origs );
+	mSize = sfor_p<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { return std::get<i>(origs)->size(); },
+	      [&](auto a, auto b) { return a * b; } );
 	if(sizeof...(RangeTypes)){
 	    mEmpty = false;
 	}
@@ -157,7 +159,9 @@ namespace MultiArrayTools
     {
 	auto rst = std::make_tuple(origs...);
 	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( rst, mOrig );
-	mSize = RPackNum<sizeof...(RangeTypes)-1>::getSize( rst );
+	mSize = sfor_p<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { return std::get<i>(rst)->size(); },
+	      [&](auto a, auto b) { return a * b; } );
 	if(sizeof...(RangeTypes)){
 	    mEmpty = false;
 	}
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 02a4cfe..33e45d8 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -564,7 +564,7 @@ namespace MultiArrayTools
     template <class... Ranges>
     size_t MultiRange<Ranges...>::getMeta(const MetaType& metaPos) const
     {
-	return RPackNum<sizeof...(Ranges)-1>::getMeta(mSpace,metaPos);
+	return RangeHelper::getMeta<sizeof...(Ranges)-1>(mSpace,metaPos);
     }
 
     template <class... Ranges>
@@ -593,7 +593,10 @@ namespace MultiArrayTools
     template <class... Ranges>
     size_t MultiRange<Ranges...>::size() const
     {
-	return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
+	return sfor_p<0,sizeof...(Ranges)>
+	    ( [&](auto i) { return std::get<i>(mSpace)->size(); },
+	      [&](auto a, auto b) { return a * b; } );
+	//return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
     }
 
     template <class... Ranges>
@@ -612,7 +615,7 @@ namespace MultiArrayTools
     vector<size_t> MultiRange<Ranges...>::typeNum() const
     {
         vector<size_t> o;
-        RPackNum<sizeof...(Ranges)-1>::getTypeNum(o,mSpace);
+	RangeHelper::getTypeNum<sizeof...(Ranges)-1>(o,mSpace);
         return o;
     }
 
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 88d2c3a..164cb16 100644
--- a/src/include/ranges/range_helper.h
+++ b/src/include/ranges/range_helper.h
@@ -16,6 +16,30 @@ namespace MultiArrayTools
 		setIndexPack<N-1>(iPack, (pos - ownPos) / i.max() );
 	    }
 	}
+
+	template <size_t N, class... Ranges>
+	inline size_t getMeta(const std::tuple<std::shared_ptr<Ranges>...>& space,
+			      const std::tuple<typename Ranges::IndexType::MetaType...>& meta)
+	{
+	    if constexpr(N != 0){
+		return getMeta<N-1>(space,meta) * std::get<N>(space)->size() +
+		    std::get<N>(space)->getMeta(std::get<N>(meta));
+	    }
+	    else {
+		return std::get<0>(space)->getMeta(std::get<0>(meta));
+	    }
+	}
+
+	template <size_t N, class... Ranges>
+	inline void getTypeNum(vector<size_t>& res, const std::tuple<std::shared_ptr<Ranges>...>& stp)
+	{
+	    auto& r = *std::get<N>(stp);
+	    auto tn = r.typeNum();
+	    res.insert(res.begin(), tn.begin(), tn.end());
+	    if constexpr(N != 0){
+		getTypeNum<N-1>(res, stp);
+	    }
+	}
 	
     } // namespace RangeHelper
 } // namespace MultiArrayTools
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index 600943c..4c474c9 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -33,13 +33,6 @@ namespace MultiArrayHelper
 	v.insert(v.begin(), r);
     }
     
-    template <size_t N>
-    template <class RangeTuple>
-    size_t RPackNum<N>::getSize(const RangeTuple& rt)
-    {
-        return std::get<N>(rt)->size() * RPackNum<N-1>::getSize(rt);
-    }
-	
     template <size_t N>
     template <class... Indices>
     inline size_t RPackNum<N>::makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
@@ -215,33 +208,7 @@ namespace MultiArrayHelper
         return r.cmetaSize() + RPackNum<N-1>::getCMetaSize(stp);
     }
 
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::getTypeNum(vector<size_t>& res, const std::tuple<std::shared_ptr<Ranges>...>& stp)
-    {
-        auto& r = *std::get<N>(stp);
-        auto tn = r.typeNum();
-        res.insert(res.begin(), tn.begin(), tn.end());
-        RPackNum<N-1>::getTypeNum(res, stp);
-    }
 
-    template <size_t N>
-    template <class... Ranges>
-    inline size_t RPackNum<N>::getMeta(const std::tuple<std::shared_ptr<Ranges>...>& space,
-				       const std::tuple<typename Ranges::IndexType::MetaType...>& meta)
-    {
-	return RPackNum<N-1>::getMeta(space,meta) * std::get<N>(space)->size() +
-	    std::get<N>(space)->getMeta(std::get<N>(meta));
-    }
-
-    
-
-    template <class RangeTuple>
-    size_t RPackNum<0>::getSize(const RangeTuple& rt)
-    {
-        return std::get<0>(rt)->size();
-    }
-	
     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)
@@ -388,20 +355,6 @@ namespace MultiArrayHelper
         return r.cmetaSize();
     }
 
-    template <class... Ranges>
-    inline void RPackNum<0>::getTypeNum(vector<size_t>& res, const std::tuple<std::shared_ptr<Ranges>...>& stp)
-    {
-        auto& r = *std::get<0>(stp);
-        auto tn = r.typeNum();
-        res.insert(res.begin(), tn.begin(), tn.end());
-    }
-
-    template <class... Ranges>
-    inline size_t RPackNum<0>::getMeta(const std::tuple<std::shared_ptr<Ranges>...>& space,
-				       const std::tuple<typename Ranges::IndexType::MetaType...>& meta)
-    {
-	return std::get<0>(space)->getMeta(std::get<0>(meta));
-    }
 
     
     template <IndexType IT>
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index 4ef41ef..3459c3b 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -102,9 +102,6 @@ namespace MultiArrayHelper
     struct RPackNum
     {
 	
-	template <class RangeTuple>
-	static size_t getSize(const RangeTuple& rt);
-	
 	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);
@@ -175,12 +172,6 @@ namespace MultiArrayHelper
         template <class... Ranges>
         static inline size_t getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp);
 
-        template <class... Ranges>
-        static inline void getTypeNum(vector<size_t>& res, const std::tuple<std::shared_ptr<Ranges>...>& stp);
-
-	template <class... Ranges>
-	static inline size_t getMeta(const std::tuple<std::shared_ptr<Ranges>...>& space,
-				     const std::tuple<typename Ranges::IndexType::MetaType...>& meta);
     };
 
     
@@ -188,9 +179,6 @@ namespace MultiArrayHelper
     struct RPackNum<0>
     {
 
-	template <class RangeTuple>
-	static size_t getSize(const RangeTuple& rt);
-	
 	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);
@@ -259,12 +247,6 @@ namespace MultiArrayHelper
         template <class... Ranges>
         static inline size_t getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp);
 
-        template <class... Ranges>
-        static inline void getTypeNum(vector<size_t>& res, const std::tuple<std::shared_ptr<Ranges>...>& stp);
-
-	template <class... Ranges>
-	static inline size_t getMeta(const std::tuple<std::shared_ptr<Ranges>...>& space,
-				     const std::tuple<typename Ranges::IndexType::MetaType...>& meta);
     };
     
     template <IndexType IT>
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index 50b2229..9dd7c07 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -258,7 +258,7 @@ namespace MultiArrayHelper
     class DExtTX
     {
     private:
-	mutable DExt mDExt = nullptr;
+	mutable DExt mDExt;
 	X mNext;
 
         template <class Y>
@@ -268,7 +268,8 @@ namespace MultiArrayHelper
 	static constexpr size_t SIZE = NUM + 1;
 	
         DExtTX() { mDExt = std::make_shared<ExtT<None>>(); }
-        DExtTX(const DExtTX& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
+        DExtTX(const DExtTX& in) : mNext(in.mNext)
+	{ mDExt = in.mDExt->deepCopy(); }
         DExtTX(DExtTX&& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
         DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
         DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }

From 12c79b595fb66a2d33c94ae9e1bf33fcb06a0673 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 27 May 2021 12:15:44 +0200
Subject: [PATCH 28/56] rpacknum: replace mkfor

---
 src/include/map_range.cc.h           |  7 ++--
 src/include/ranges/container_range.h | 12 ++----
 src/include/ranges/multi_range.h     |  8 ++--
 src/include/ranges/range_helper.h    | 40 ++++++++++++++++++
 src/include/ranges/rpack_num.cc.h    | 63 ----------------------------
 src/include/ranges/rpack_num.h       | 30 -------------
 src/include/xfor/exttype.h           |  3 +-
 7 files changed, 52 insertions(+), 111 deletions(-)

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index fcb2a49..91d707c 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -309,9 +309,10 @@ namespace MultiArrayTools
     template <class Exprs>
     auto GenMapIndex<OIType,Op,XSTYPE,Indices...>::ifor(size_t step, Exprs exs) const
     {
-	return RPackNum<sizeof...(Indices)-1>::mkForh
-	    (0, mIPack, mBlockSizes, OpExpr<Op,GenMapIndex<OIType,Op,XSTYPE,Indices...>,Exprs,XSTYPE>
-	     ( range()->map(), this, step, exs ) );
+	return RangeHelper::mkFor<0>
+	    (0, mIPack, mBlockSizes,
+	     OpExpr<Op,GenMapIndex<OIType,Op,XSTYPE,Indices...>,Exprs,XSTYPE>
+	     ( range()->map(), this, step, exs ));
     }
 
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index 34d0b3c..de606dc 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -159,15 +159,12 @@ namespace MultiArrayTools
 	
 	template <class Exprs>
 	auto ifor(size_t step, Exprs exs) const;
-	//-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs));
 
 	template <class Exprs>
 	auto iforh(size_t step, Exprs exs) const;
-	//  -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs));
 
         template <class Exprs>
 	auto pifor(size_t step, Exprs exs) const;
-	//  -> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs));
 
 	std::intptr_t container() const;
 	ContainerIndex& format(const std::array<size_t,sizeof...(Indices)+1>& blocks);
@@ -482,25 +479,22 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     template <class Exprs>
     auto ContainerIndex<T,Indices...>::ifor(size_t step, Exprs exs) const
-    //	-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs))
     {
-	return RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs);
+	return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <typename T, class... Indices>
     template <class Exprs>
     auto ContainerIndex<T,Indices...>::iforh(size_t step, Exprs exs) const
-    //	-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs))
     {
-	return RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs);
+	return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <typename T, class... Indices>
     template <class Exprs>
     auto ContainerIndex<T,Indices...>::pifor(size_t step, Exprs exs) const
-    //	-> decltype(RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs))
     {
-	return RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs);
+	return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <typename T, class... Indices>
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 33e45d8..cef2e02 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -473,21 +473,21 @@ namespace MultiArrayTools
     template <class Exprs>
     auto MultiIndex<Indices...>::ifor(size_t step, Exprs exs) const
     {
-	return RPackNum<sizeof...(Indices)-1>::mkFor(step, mIPack, mBlockSizes, exs);
+	return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <class... Indices>
     template <class Exprs>
     auto MultiIndex<Indices...>::iforh(size_t step, Exprs exs) const
     {
-	return RPackNum<sizeof...(Indices)-1>::mkForh(step, mIPack, mBlockSizes, exs);
+	return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <class... Indices>
     template <class Exprs>
     auto MultiIndex<Indices...>::pifor(size_t step, Exprs exs) const
     {
-	return RPackNum<sizeof...(Indices)-1>::mkPFor(step, mIPack, mBlockSizes, exs);
+	return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs);
     }
 
     /*************************
@@ -581,7 +581,6 @@ namespace MultiArrayTools
 	return sforx_p<0,sizeof...(Indices)>
 	    ( [&](auto i) { return std::dynamic_pointer_cast<RangeBase>(std::get<i>(mSpace)); },
 	      [&](auto i) { return num != i;} );
-	//return RPackNum<sizeof...(Indices)-1>::getSub(mSpace, num);
     }
 
     template <class... Ranges>
@@ -596,7 +595,6 @@ namespace MultiArrayTools
 	return sfor_p<0,sizeof...(Ranges)>
 	    ( [&](auto i) { return std::get<i>(mSpace)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
-	//return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
     }
 
     template <class... Ranges>
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 164cb16..40cebb1 100644
--- a/src/include/ranges/range_helper.h
+++ b/src/include/ranges/range_helper.h
@@ -40,6 +40,46 @@ namespace MultiArrayTools
 		getTypeNum<N-1>(res, stp);
 	    }
 	}
+
+	template <size_t N, class IndexPack, class BlockArray, class Exprs>
+	auto mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
+	{
+	    constexpr size_t S = std::tuple_size<IndexPack>::value;
+	    if constexpr(N < S-1){
+		return std::get<N>(ipack)
+		    ->ifor( step*std::get<N+1>(ba), mkFor<N+1>(step, ipack, ba, exs) );
+	    }
+	    else {
+		return std::get<N>(ipack)->ifor( step*std::get<N+1>(ba), exs);
+	    }
+	}
+
+	template <size_t N, class IndexPack, class BlockArray, class Exprs>
+	auto mkForh(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
+	{
+	    constexpr size_t S = std::tuple_size<IndexPack>::value;
+	    if constexpr(N < S-1){
+		return std::get<N>(ipack)
+		    ->iforh( step*std::get<N+1>(ba), mkForh<N+1>(step, ipack, ba, exs) );
+	    }
+	    else {
+		return std::get<N>(ipack)->iforh( step*std::get<N+1>(ba), exs);
+	    }
+	}
+
+	template <size_t N, class IndexPack, class BlockArray, class Exprs>
+	auto mkPFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
+	{
+	    constexpr size_t S = std::tuple_size<IndexPack>::value;
+	    if constexpr(N < S-1){
+		return std::get<N>(ipack)
+		    ->pifor( step*std::get<N+1>(ba), mkFor<N+1>(step, ipack, ba, exs) );
+		// mkFor is correct here, because we want to multithread only the FIRST index!!
+	    }
+	    else {
+		return std::get<N>(ipack)->pifor( step*std::get<N+1>(ba), exs);
+	    }
+	}
 	
     } // namespace RangeHelper
 } // namespace MultiArrayTools
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index 4c474c9..c8ae94c 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -84,39 +84,6 @@ namespace MultiArrayHelper
         RPackNum<N-1>::RangesToVec(rst, v);
     }
 
-    template <size_t N>
-    template <class IndexPack, class BlockArray, class Exprs>
-    auto RPackNum<N>::mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-        -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
-                    ->ifor( 0, RPackNum<N-1>::mkFor(step, ipack, ba, exs) ) )
-    {
-        constexpr size_t NN = std::tuple_size<IndexPack>::value-N-1;
-        return std::get<NN>(ipack)
-            ->ifor( step*std::get<NN+1>(ba), RPackNum<N-1>::mkFor(step, ipack, ba, exs) );
-    }
-
-    template <size_t N>
-    template <class IndexPack, class BlockArray, class Exprs>
-    auto RPackNum<N>::mkForh(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-        -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
-                    ->iforh( 0, RPackNum<N-1>::mkForh(step, ipack, ba, exs) ) )
-    {
-        constexpr size_t NN = std::tuple_size<IndexPack>::value-N-1;
-        return std::get<NN>(ipack)
-            ->iforh( step*std::get<NN+1>(ba), RPackNum<N-1>::mkForh(step, ipack, ba, exs) );
-    }
-
-    template <size_t N>
-    template <class IndexPack, class BlockArray, class Exprs>
-    auto RPackNum<N>::mkPFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-        -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
-                    ->pifor( 0, RPackNum<N-1>::mkFor(step, ipack, ba, exs) ) )
-    {
-        constexpr size_t NN = std::tuple_size<IndexPack>::value-N-1;
-        return std::get<NN>(ipack)
-            ->pifor( step*std::get<NN+1>(ba), RPackNum<N-1>::mkFor(step, ipack, ba, exs) );
-        // mkFor is correct here, because we want to multithread only the FIRST index!!
-    }
 
     template <size_t N>
     template <class Index>
@@ -248,36 +215,6 @@ namespace MultiArrayHelper
         setRangeToVec(v, std::get<0>(rst));
     }
 
-    template <class IndexPack, class BlockArray, class Exprs>
-    auto RPackNum<0>::mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-        -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
-                    ->ifor(0,exs) )
-    {
-        constexpr size_t NN = std::tuple_size<IndexPack>::value-1;
-        return std::get<NN>(ipack)
-            ->ifor( step*std::get<NN+1>(ba), exs);
-    }
-
-    template <class IndexPack, class BlockArray, class Exprs>
-    auto RPackNum<0>::mkForh(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-        -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
-                    ->iforh(0,exs) )
-    {
-        constexpr size_t NN = std::tuple_size<IndexPack>::value-1;
-        return std::get<NN>(ipack)
-            ->iforh( step*std::get<NN+1>(ba), exs);
-    }
-
-    template <class IndexPack, class BlockArray, class Exprs>
-    auto RPackNum<0>::mkPFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-        -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
-                    ->pifor(0,exs) )
-    {
-        constexpr size_t NN = std::tuple_size<IndexPack>::value-1;
-        return std::get<NN>(ipack)
-            ->pifor( step*std::get<NN+1>(ba), exs);
-    }
-
     template <class Index>
     inline void RPackNum<0>::getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
     {
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index 3459c3b..9527116 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -125,21 +125,6 @@ namespace MultiArrayHelper
 	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
 				       vector<std::intptr_t>& v);
 
-	template <class IndexPack, class BlockArray, class Exprs>
-	static auto mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-	    -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
-			->ifor( 0, RPackNum<N-1>::mkFor(step, ipack, ba, exs) ) );
-
-	template <class IndexPack, class BlockArray, class Exprs>
-	static auto mkForh(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-	    -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
-			->iforh( 0, RPackNum<N-1>::mkForh(step, ipack, ba, exs) ) );
-
-        template <class IndexPack, class BlockArray, class Exprs>
-	static auto mkPFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-	    -> decltype(std::get<std::tuple_size<IndexPack>::value-N-1>(ipack)
-			->pifor( 0, RPackNum<N-1>::mkFor(step, ipack, ba, exs) ) );
-
 	template <class Index>
 	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
 
@@ -200,21 +185,6 @@ namespace MultiArrayHelper
 	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
 				       vector<std::shared_ptr<RangeBase> >& v);
 
-	template <class IndexPack, class BlockArray, class Exprs>
-	static auto mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-	    -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
-			->ifor(0,exs) );
-
-	template <class IndexPack, class BlockArray, class Exprs>
-	static auto mkForh(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-	    -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
-			->iforh(0,exs) );
-
-        template <class IndexPack, class BlockArray, class Exprs>
-	static auto mkPFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
-	    -> decltype(std::get<std::tuple_size<IndexPack>::value-1>(ipack)
-			->pifor(0,exs) );
-
 	template <class Index>
 	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
 
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index 9dd7c07..a4b6a3a 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -270,7 +270,8 @@ namespace MultiArrayHelper
         DExtTX() { mDExt = std::make_shared<ExtT<None>>(); }
         DExtTX(const DExtTX& in) : mNext(in.mNext)
 	{ mDExt = in.mDExt->deepCopy(); }
-        DExtTX(DExtTX&& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
+        DExtTX(DExtTX&& in) : mNext(in.mNext)
+	{ mDExt = in.mDExt->deepCopy(); }
         DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
         DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; }
         explicit DExtTX(const DExt& in) : mDExt(in) {}

From 6dc926f234be6684153f496fa5611c3383578961 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 27 May 2021 18:37:15 +0200
Subject: [PATCH 29/56] further packnum replacements

---
 src/include/map_range.cc.h            |  19 ++--
 src/include/ranges/anonymous_range.h  |  42 +++++----
 src/include/ranges/container_range.h  |  21 -----
 src/include/ranges/dynamic_range.cc.h |  45 ++++++----
 src/include/ranges/multi_range.h      |  15 +++-
 src/include/ranges/range_helper.h     |  28 ++++++
 src/include/ranges/rpack_num.cc.h     | 119 +-------------------------
 src/include/ranges/rpack_num.h        |  53 ------------
 8 files changed, 110 insertions(+), 232 deletions(-)

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 91d707c..9b28667 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -175,10 +175,7 @@ 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>::setIndexPack(mIPack, IB::mPos);
 	return (*this)(std::make_tuple(indices...));
-	//return *this;
     }
 
     template <class OIType, class Op, SpaceType XSTYPE, class... Indices>
@@ -186,7 +183,6 @@ namespace MultiArrayTools
     {
 	sfor_pn<0,sizeof...(Indices)>
 	    ( [&](auto i) { std::get<i>(mIPack) = std::get<i>(indices); return 0; } );
-	//RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
 	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, IB::mPos);
 	return *this;
     }
@@ -386,7 +382,9 @@ namespace MultiArrayTools
 	bool check = false;
 	for(auto& x: MapRangeFactoryProductMap::mAleadyCreated){
 	    if(x.second.size() == sizeof...(Ranges)){
-		check = RPackNum<sizeof...(Ranges)-1>::checkIfCreated(ptp, x.second);
+		check = sfor_p<0,sizeof...(Ranges)>
+		    ( [&](auto i) { return reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ) == x.second[i]; },
+		      [&](auto a, auto b) { return a and b; } );
 		if(check){
 		    out = x.first;
 		    break;
@@ -395,7 +393,8 @@ namespace MultiArrayTools
 	}
 	if(not check){
 	    vector<std::intptr_t> pv(sizeof...(Ranges));
-	    RPackNum<sizeof...(Ranges)-1>::RangesToVec(ptp, pv);
+	    sfor_pn<0,sizeof...(Ranges)>
+		( [&](auto i) { pv[i] = reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ); return 0; } );
 	    pv.push_back( reinterpret_cast<std::intptr_t>
 			  ( &std::dynamic_pointer_cast<oType>( mProd )->mMapf ) );
 	    MapRangeFactoryProductMap::mAleadyCreated[mProd] = pv;
@@ -626,7 +625,13 @@ namespace MultiArrayTools
 	//out.reserve(h.metaSize + sizeof(DataHeader));
 	char* hcp = reinterpret_cast<char*>(&h);
 	out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
-	RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
+	sfor_pn<0,sizeof...(Ranges)>
+	    ( [&](auto i) {
+		vector<char> part = std::get<i>(mSpace)->data();
+		out.insert(out.end(), part.begin(), part.end());
+		return 0;
+	    } );
+	//RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
 	return out;
     }
 
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index 48a5a00..175c279 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/src/include/ranges/anonymous_range.h
@@ -171,23 +171,28 @@ namespace MultiArrayTools
 
     std::shared_ptr<AnonymousRange> defaultRange(size_t size = 0);
 }
-
+namespace MultiArrayTools
+{
+    namespace RangeHelper
+    {
+	template <>
+	inline void resolveSetRange<AnonymousRange>(std::shared_ptr<AnonymousRange>& rp,
+						    const vector<std::shared_ptr<RangeBase> >& orig,
+						    size_t origpos, size_t size)
+	{
+	    AnonymousRangeFactory arf;
+	    for(size_t op = origpos; op != origpos + size; ++op){
+		//VCHECK(op);
+		arf.append(orig[op]);
+	    }
+	    rp = std::dynamic_pointer_cast<AnonymousRange>( arf.create() );
+	}
+    }
+}
 namespace MultiArrayHelper
 {
     using namespace MultiArrayTools;
 
-    template <>
-    inline void resolveSetRange<AnonymousRange>(std::shared_ptr<AnonymousRange>& rp,
-						const vector<std::shared_ptr<RangeBase> >& orig,
-						size_t origpos, size_t size)
-    {
-    	AnonymousRangeFactory arf;
-	for(size_t op = origpos; op != origpos + size; ++op){
-	    //VCHECK(op);
-	    arf.append(orig[op]);
-	}
-    	rp = std::dynamic_pointer_cast<AnonymousRange>( arf.create() );
-    }
 
     template <>
     inline void setRangeToVec<AnonymousRange>(vector<std::shared_ptr<RangeBase> >& v,
@@ -212,7 +217,9 @@ namespace MultiArrayTools
     GenSingleRange<size_t,SpaceType::ANON,MUI>::GenSingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
 	RangeInterface<AnonymousIndex>()
     {
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(origs); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(origs)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -226,7 +233,9 @@ namespace MultiArrayTools
 	RangeInterface<AnonymousIndex>()
     {
 	auto rst = std::make_tuple(origs...);
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( rst, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(rst); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(rst)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -245,7 +254,8 @@ namespace MultiArrayTools
     std::shared_ptr<MultiRange<Ranges...> > GenSingleRange<size_t,SpaceType::ANON,MUI>::scast(SIZET<Ranges>... sizes) const
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
-	RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
+	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() );
     }
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index de606dc..fb0d9ce 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -154,9 +154,6 @@ namespace MultiArrayTools
 
 	size_t getStepSize(size_t n);
 
-	std::string id() const;
-	void print(size_t offset);
-	
 	template <class Exprs>
 	auto ifor(size_t step, Exprs exs) const;
 
@@ -457,24 +454,6 @@ namespace MultiArrayTools
 	}
 	return mBlockSizes[n+1];
     }
-    
-    template <typename T, class... Indices>
-    std::string ContainerIndex<T,Indices...>::id() const
-    {
-	return std::string("con") + std::to_string(IB::mId);
-    }
-
-    template <typename T, class... Indices>
-    void ContainerIndex<T,Indices...>::print(size_t offset)
-    {
-	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 <typename T, class... Indices>
     template <class Exprs>
diff --git a/src/include/ranges/dynamic_range.cc.h b/src/include/ranges/dynamic_range.cc.h
index e5ae01f..e9b491a 100644
--- a/src/include/ranges/dynamic_range.cc.h
+++ b/src/include/ranges/dynamic_range.cc.h
@@ -143,7 +143,9 @@ namespace MultiArrayTools
     DynamicRange::DynamicRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
 	RangeInterface<DynamicIndex>()
     {
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(origs); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(origs)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -158,7 +160,9 @@ namespace MultiArrayTools
 	RangeInterface<DynamicIndex>()
     {
 	auto rst = std::make_tuple(origs...);
-	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( rst, mOrig );
+	mOrig.resize(sizeof...(RangeTypes));
+	sfor_pn<0,sizeof...(RangeTypes)>
+	    ( [&](auto i) { mOrig[i] = std::get<i>(rst); return 0; } );
 	mSize = sfor_p<0,sizeof...(RangeTypes)>
 	    ( [&](auto i) { return std::get<i>(rst)->size(); },
 	      [&](auto a, auto b) { return a * b; } );
@@ -179,7 +183,8 @@ namespace MultiArrayTools
     std::shared_ptr<MultiRange<Ranges...> > DynamicRange::scast(SIZET<Ranges>... sizes) const
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
-	RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
+	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() );
     }
@@ -187,25 +192,33 @@ namespace MultiArrayTools
     
 } // end namespace MultiArrayTools
 
+namespace MultiArrayTools
+{
+    namespace RangeHelper
+    {
+	template <>
+	inline void resolveSetRange<DynamicRange>(std::shared_ptr<DynamicRange>& rp,
+						  const vector<std::shared_ptr<RangeBase> >& orig,
+						  size_t origpos, size_t size)
+	{
+	    DynamicRangeFactory arf;
+	    for(size_t op = origpos; op != origpos + size; ++op){
+		//VCHECK(op);
+		arf.append(orig[op]);
+	    }
+	    rp = std::dynamic_pointer_cast<DynamicRange>( arf.create() );
+	}
+	
+    }
+}
+
 namespace MultiArrayHelper
 {
     namespace
     {
         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)
-    {
-    	DynamicRangeFactory arf;
-	for(size_t op = origpos; op != origpos + size; ++op){
-	    //VCHECK(op);
-	    arf.append(orig[op]);
-	}
-    	rp = std::dynamic_pointer_cast<DynamicRange>( arf.create() );
-    }
+    
 
     template <>
     inline void setRangeToVec<DynamicRange>(vector<std::shared_ptr<RangeBase> >& v,
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index cef2e02..dd62c87 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -528,7 +528,9 @@ namespace MultiArrayTools
 	bool check = false;
 	for(auto& x: MultiRangeFactoryProductMap::mAleadyCreated){
 	    if(x.second.size() == sizeof...(Ranges)){
-		check = RPackNum<sizeof...(Ranges)-1>::checkIfCreated(ptp, x.second);
+		check = sfor_p<0,sizeof...(Ranges)>
+		    ( [&](auto i) { return reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ) == x.second[i]; },
+		      [&](auto a, auto b) { return a and b; } );
 		if(check){
 		    out = x.first;
 		    break;
@@ -537,7 +539,8 @@ namespace MultiArrayTools
 	}
 	if(not check){
 	    vector<std::intptr_t> pv(sizeof...(Ranges));
-	    RPackNum<sizeof...(Ranges)-1>::RangesToVec(ptp, pv);
+	    sfor_pn<0,sizeof...(Ranges)>
+		( [&](auto i) { pv[i] = reinterpret_cast<std::intptr_t>( std::get<i>(ptp).get() ); return 0; } );
 	    MultiRangeFactoryProductMap::mAleadyCreated[mProd] = pv;
 	    out = mProd;
 	}
@@ -647,7 +650,13 @@ namespace MultiArrayTools
 	//out.reserve(h.metaSize + sizeof(DataHeader));
 	char* hcp = reinterpret_cast<char*>(&h);
 	out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
-	RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
+	sfor_pn<0,sizeof...(Ranges)>
+	    ( [&](auto i) {
+		vector<char> part = std::get<i>(mSpace)->data();
+		out.insert(out.end(), part.begin(), part.end());
+		return 0;
+	    } );
+	//RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
 	return out;
     }
 
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 40cebb1..6c196b2 100644
--- a/src/include/ranges/range_helper.h
+++ b/src/include/ranges/range_helper.h
@@ -6,6 +6,14 @@ namespace MultiArrayTools
 {
     namespace RangeHelper
     {
+	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 <size_t N, class IndexPack>
 	void setIndexPack(IndexPack& iPack, size_t pos)
 	{
@@ -80,6 +88,26 @@ namespace MultiArrayTools
 		return std::get<N>(ipack)->pifor( step*std::get<N+1>(ba), exs);
 	    }
 	}
+
+	template <size_t N, class RangeTuple, typename... SIZET>
+	inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
+				     RangeTuple& rtp, size_t off, size_t size, SIZET... sizes)
+	{
+	    constexpr size_t tps = std::tuple_size<RangeTuple>::value;
+	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
+	    if constexpr(N < tps-1){
+		resolveRangeType<N+1>(orig, rtp, off+size, sizes...);
+	    }
+	}
+
+	template <size_t N, class RangeTuple>
+	inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
+				     RangeTuple& rtp, size_t off, size_t size)
+	{
+	    constexpr size_t tps = std::tuple_size<RangeTuple>::value;
+	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
+	}
+
 	
     } // namespace RangeHelper
 } // namespace MultiArrayTools
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
index c8ae94c..28c737e 100644
--- a/src/include/ranges/rpack_num.cc.h
+++ b/src/include/ranges/rpack_num.cc.h
@@ -1,5 +1,6 @@
 
 #include "rpack_num.h"
+
 namespace MultiArrayHelper
 {
     using namespace MultiArrayTools;
@@ -17,7 +18,7 @@ namespace MultiArrayHelper
     }
 
 
-    
+    /*
     template <class Range>
     inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
 				size_t origpos, size_t size)
@@ -25,6 +26,7 @@ namespace MultiArrayHelper
 	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,
@@ -41,23 +43,6 @@ namespace MultiArrayHelper
         return RPackNum<N-1>::makePos(iPtrTup, blockSize) + std::get<N>(iPtrTup)->pos() * std::get<N+1>(blockSize);
     }
 
-    template <size_t N>
-    template <class Pack, class IndexType, class... Indices>
-    void RPackNum<N>::swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind,
-                                         const std::shared_ptr<Indices>&... ninds)
-    {
-        std::get<std::tuple_size<Pack>::value-N-1>(ipack) = nind;
-        RPackNum<N-1>::swapIndices(ipack, ninds...);
-    }
-
-    template <size_t N>
-    template <class Pack, class... Indices>
-    void RPackNum<N>::swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds)
-    {
-        std::get<N>(ipack) = std::get<N>(ninds);
-        RPackNum<N-1>::swapIndices(ipack, ninds);
-    }
-
     template <size_t N>
     template <class... Indices>
     size_t RPackNum<N>::blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
@@ -65,26 +50,6 @@ namespace MultiArrayHelper
         return std::get<sizeof...(Indices)-N>(pack)->max() * RPackNum<N-1>::blockSize(pack);
     }
 
-
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::shared_ptr<RangeBase> >& v)
-    {
-        setRangeToVec(v, std::get<N>(rst));
-        RPackNum<N-1>::RangesToVec(rst, v);
-    }
-
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::intptr_t>& v)
-    {
-        v[N] = reinterpret_cast<std::intptr_t>( std::get<N>(rst).get() );
-        RPackNum<N-1>::RangesToVec(rst, v);
-    }
-
-
     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)
@@ -99,25 +64,6 @@ namespace MultiArrayHelper
         RPackNum<N-1>::getStepSizeX(ii, j, ss, sx);
     }
 
-    template <size_t N>
-    template <class RangeTuple, typename... SIZET>
-    inline void RPackNum<N>::resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-                                                     RangeTuple& rtp, size_t off, size_t size, SIZET... sizes)
-    {
-        constexpr size_t tps = std::tuple_size<RangeTuple>::value;
-        resolveSetRange(std::get<tps-N-1>(rtp), orig, off, size);
-        RPackNum<N-1>::resolveRangeType(orig, rtp, off+size, sizes...);
-    }
-
-    template <size_t N>
-    template <class... Ranges>
-    inline bool RPackNum<N>::checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-                                                   const vector<std::intptr_t>& a)
-    {
-        return reinterpret_cast<std::intptr_t>( std::get<N>(p).get() ) == a[N] and
-            RPackNum<N-1>::checkIfCreated(p,a);
-    }
-
     template <size_t N>
     template <class MIndex>
     inline std::string RPackNum<N>::getStringMeta(const MIndex& mi)
@@ -125,16 +71,6 @@ namespace MultiArrayHelper
         return RPackNum<N-1>::getStringMeta(mi) + "," + mi.template getPtr<N>()->stringMeta();
     }
 
-    template <size_t N>
-    template <class... Ranges>
-    inline void RPackNum<N>::fillRangeDataVec(vector<char>& out,
-                                                     const std::tuple<std::shared_ptr<Ranges>...>& tp)
-    {
-        vector<char> part = std::get<sizeof...(Ranges)-N-1>(tp)->data();
-        out.insert(out.end(), part.begin(), part.end());
-        RPackNum<N-1>::fillRangeDataVec(out, tp);
-    }
-
     template <size_t N>
     template <size_t SIZE, class Range, class... Ranges>
     inline bool RPackNum<N>::compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
@@ -183,38 +119,12 @@ namespace MultiArrayHelper
         return std::get<0>(iPtrTup)->pos() * std::get<1>(blockSize);
     }
 
-    template <class Pack, class IndexType>
-    void RPackNum<0>::swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind)
-    {
-        std::get<std::tuple_size<Pack>::value-1>(ipack) = nind;
-    }
-
-    template <class Pack, class... Indices>
-    void RPackNum<0>::swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds)
-    {
-        std::get<0>(ipack) = std::get<0>(ninds);
-    }
-
     template <class... Indices>
     size_t RPackNum<0>::blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
     {
         return 1;
     }
 
-    template <class... Ranges>
-    inline void RPackNum<0>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::intptr_t>& v)
-    {
-        v[0] = reinterpret_cast<std::intptr_t>( std::get<0>(rst).get() );;
-    }
-	
-    template <class... Ranges>
-    inline void RPackNum<0>::RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-                                                vector<std::shared_ptr<RangeBase> >& v)
-    {
-        setRangeToVec(v, std::get<0>(rst));
-    }
-
     template <class Index>
     inline void RPackNum<0>::getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
     {
@@ -227,35 +137,12 @@ namespace MultiArrayHelper
         sx *= max;
     }
 
-    template <class RangeTuple, typename... SIZET>
-    inline void RPackNum<0>::resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-                                                     RangeTuple& rtp, size_t off, size_t size)
-    {
-        constexpr size_t tps = std::tuple_size<RangeTuple>::value;
-        resolveSetRange(std::get<tps-1>(rtp), orig, off, size);
-    }
-
-    template <class... Ranges>
-    inline bool RPackNum<0>::checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-                                                   const vector<std::intptr_t>& a)
-    {
-        return reinterpret_cast<std::intptr_t>( std::get<0>(p).get() ) == a[0];
-    }
-
     template <class MIndex>
     inline std::string RPackNum<0>::getStringMeta(const MIndex& mi)
     {
         return mi.template getPtr<0>()->stringMeta();
     }
 
-    template <class... Ranges>
-    inline void RPackNum<0>::fillRangeDataVec(vector<char>& out,
-                                                     const std::tuple<std::shared_ptr<Ranges>...>& tp)
-    {
-        vector<char> part = std::get<sizeof...(Ranges)-1>(tp)->data();
-        out.insert(out.end(), part.begin(), part.end());
-    }
-
     template <size_t SIZE, class Range>
     inline bool RPackNum<0>::compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
     {
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index 9527116..c640aaa 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -106,43 +106,16 @@ namespace MultiArrayHelper
 	static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize);
 
-	template <class Pack, class IndexType, class... Indices>
-	static void swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind,
-				const std::shared_ptr<Indices>&... ninds);
-
-        template <class Pack, class... Indices>
-	static void swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds);
-
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack);
 
 
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::shared_ptr<RangeBase> >& v);
-
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::intptr_t>& v);
-
 	template <class Index>
 	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
 
-	template <class RangeTuple, typename... SIZET>
-	static inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-					    RangeTuple& rtp, size_t off, size_t size, SIZET... sizes);
-
-	template <class... Ranges>
-	static inline bool checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-					  const vector<std::intptr_t>& a);
-
 	template <class MIndex>
 	static inline std::string getStringMeta(const MIndex& mi);
 
-	template <class... Ranges>
-	static inline void fillRangeDataVec(vector<char>& out,
-					    const std::tuple<std::shared_ptr<Ranges>...>& tp);
-
 	template <size_t SIZE, class Range, class... Ranges>
 	static inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec);
 
@@ -168,41 +141,15 @@ namespace MultiArrayHelper
 	static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize);
 
-	template <class Pack, class IndexType>
-	static void swapIndices(Pack& ipack, const std::shared_ptr<IndexType>& nind);
-
-        template <class Pack, class... Indices>
-	static void swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds);
-
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack);
 
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::intptr_t>& v);
-	
-	template <class... Ranges>
-	static inline void RangesToVec(const std::tuple<std::shared_ptr<Ranges>...>& rst,
-				       vector<std::shared_ptr<RangeBase> >& v);
-
 	template <class Index>
 	static inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx);
 
-	template <class RangeTuple, typename... SIZET>
-	static inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
-					    RangeTuple& rtp, size_t off, size_t size);
-
-	template <class... Ranges>
-	static inline bool checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& p,
-					  const vector<std::intptr_t>& a);
-
         template <class MIndex>
 	static inline std::string getStringMeta(const MIndex& mi);
 
-	template <class... Ranges>
-	static inline void fillRangeDataVec(vector<char>& out,
-					    const std::tuple<std::shared_ptr<Ranges>...>& tp);
-
 	template <size_t SIZE, class Range>
 	static inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec);
 

From c5b9e844864a792d706cdcbba9211742ffa78ea7 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 27 May 2021 23:29:04 +0200
Subject: [PATCH 30/56] completely remove rpacknum

---
 src/include/map_range.cc.h             |   5 +-
 src/include/map_range.h                |   7 +-
 src/include/multi_array_operation.cc.h |  12 +-
 src/include/ranges/anonymous_range.h   |  22 +--
 src/include/ranges/container_range.h   |  22 ++-
 src/include/ranges/dynamic_range.cc.h  |  61 +++----
 src/include/ranges/dynamic_range.h     |  32 ++--
 src/include/ranges/index_wrapper.cc.h  |   6 +-
 src/include/ranges/multi_range.h       |  19 +--
 src/include/ranges/range_helper.h      | 172 +++++++++++++++++++-
 src/include/ranges/ranges_header.cc.h  |   1 -
 src/include/ranges/rpack_num.cc.h      | 210 -------------------------
 src/include/ranges/rpack_num.h         | 188 ----------------------
 src/include/ranges/single_range.h      |   4 -
 src/include/ranges/subrange.h          |   1 -
 src/lib/ranges/range_base.cc           |   6 +-
 16 files changed, 251 insertions(+), 517 deletions(-)
 delete mode 100644 src/include/ranges/rpack_num.cc.h
 delete mode 100644 src/include/ranges/rpack_num.h

diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 9b28667..d43c481 100644
--- a/src/include/map_range.cc.h
+++ b/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;
     }
 
diff --git a/src/include/map_range.h b/src/include/map_range.h
index 6bd6e4d..19240dd 100644
--- a/src/include/map_range.h
+++ b/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 SIZE = SubProp<Op,Ranges...>::SIZE;
+	static constexpr size_t ISSTATIC = Op::ISSTATIC & (... & Ranges::ISSTATIC);
+	static constexpr size_t SIZE = Op::SIZE * (... * Ranges::SIZE);
     };
 
     // for legacy
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index d1e417c..dbee69f 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/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>(getStepSize( getRootIndices( mIndex->info() ), iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( mIndex, 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>(getStepSize( getRootIndices( mIndex->info() ), iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( *mIndex, 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>(getStepSize( mIndex.info(), iPtrNum ));
+	return MExt<None>(RangeHelper::getStepSize( mIndex, iPtrNum ));
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index 175c279..9d4a4ab 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/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 <>
-    inline void setRangeToVec<AnonymousRange>(vector<std::shared_ptr<RangeBase> >& v,
-					      std::shared_ptr<AnonymousRange> r)
-    {
-	if(not r->isEmpty()){
-	    for(size_t i = r->anonymousDim(); i != 0; --i){
-		v.insert(v.begin(), r->sub(i-1));
+	template <>
+	inline void setRangeToVec<AnonymousRange>(vector<std::shared_ptr<RangeBase> >& v,
+						  std::shared_ptr<AnonymousRange> r)
+	{
+	    if(not r->isEmpty()){
+		for(size_t i = r->anonymousDim(); i != 0; --i){
+		    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() );
     }
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index fb0d9ce..35b9b17 100644
--- a/src/include/ranges/container_range.h
+++ b/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;
     }
 
diff --git a/src/include/ranges/dynamic_range.cc.h b/src/include/ranges/dynamic_range.cc.h
index e9b491a..99fc800 100644
--- a/src/include/ranges/dynamic_range.cc.h
+++ b/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() );
     }
@@ -208,44 +204,35 @@ namespace MultiArrayTools
 	    }
 	    rp = std::dynamic_pointer_cast<DynamicRange>( arf.create() );
 	}
-	
-    }
-}
-
-namespace MultiArrayHelper
-{
-    namespace
-    {
-        using namespace MultiArrayTools;
-    }
     
 
-    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 <>
+	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 <>
-    inline size_t getStepSize<DynamicIndex>(const DynamicIndex& ii, std::intptr_t j)
-    {
-        size_t ss = 0;
-        size_t sx = 1;
-        for(size_t k = ii.dim(); k != 0; --k){
-	    const size_t i = k-1;
-            const auto& ni = ii.get(i);
-            const size_t max = ni.max();
-            const size_t tmp = ni.getStepSizeComp(j);
-            ss += tmp * ii.getStepSize(i);
-            sx *= max;
-        }
-        return ss;
+	template <>
+	inline size_t getStepSize<DynamicIndex>(const DynamicIndex& ii, std::intptr_t j)
+	{
+	    size_t ss = 0;
+	    size_t sx = 1;
+	    for(size_t k = ii.dim(); k != 0; --k){
+		const size_t i = k-1;
+		const auto& ni = ii.get(i);
+		const size_t max = ni.max();
+		const size_t tmp = ni.getStepSizeComp(j);
+		ss += tmp * ii.getStepSize(i);
+		sx *= max;
+	    }
+	    return ss;
+	
+	}
     }
-
 }
 
diff --git a/src/include/ranges/dynamic_range.h b/src/include/ranges/dynamic_range.h
index 8431323..8a9e6bf 100644
--- a/src/include/ranges/dynamic_range.h
+++ b/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"
diff --git a/src/include/ranges/index_wrapper.cc.h b/src/include/ranges/index_wrapper.cc.h
index 234fc3b..fd23a05 100644
--- a/src/include/ranges/index_wrapper.cc.h
+++ b/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;
     }
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index dd62c87..fd3b120 100644
--- a/src/include/ranges/multi_range.h
+++ b/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 SIZE = SubProp<Ranges...>::SIZE;
+	static constexpr size_t ISSTATIC = (... & Ranges::ISSTATIC);
+	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;
     }
 
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 6c196b2..7c78c9b 100644
--- a/src/include/ranges/range_helper.h
+++ b/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,7 +181,104 @@ 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
 
diff --git a/src/include/ranges/ranges_header.cc.h b/src/include/ranges/ranges_header.cc.h
index a24c290..7254dce 100644
--- a/src/include/ranges/ranges_header.cc.h
+++ b/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"
diff --git a/src/include/ranges/rpack_num.cc.h b/src/include/ranges/rpack_num.cc.h
deleted file mode 100644
index 28c737e..0000000
--- a/src/include/ranges/rpack_num.cc.h
+++ /dev/null
@@ -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
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
deleted file mode 100644
index c640aaa..0000000
--- a/src/include/ranges/rpack_num.h
+++ /dev/null
@@ -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
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index c413af8..643bfc0 100644
--- a/src/include/ranges/single_range.h
+++ b/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
 {
diff --git a/src/include/ranges/subrange.h b/src/include/ranges/subrange.h
index 0fe2e6f..3ec6d80 100644
--- a/src/include/ranges/subrange.h
+++ b/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"
diff --git a/src/lib/ranges/range_base.cc b/src/lib/ranges/range_base.cc
index 8a42acb..6e6448a 100644
--- a/src/lib/ranges/range_base.cc
+++ b/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>::
-	    template compareSpaceTypes<sizeof...(Ranges),Ranges...>(rvec);
+	return RangeHelper::compareSpaceTypes<sizeof...(Ranges)-1,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;
 	}

From 34e69cd805d274ccc0650dcc34d5a64391674170 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 28 May 2021 17:29:13 +0200
Subject: [PATCH 31/56] ContainerIndex -> ConstContainerIndex

---
 src/include/functional_multi_array.h    |   2 +-
 src/include/map_range.h                 |   2 +-
 src/include/multi_array.h               |   2 +-
 src/include/multi_array_base.cc.h       |   4 +-
 src/include/multi_array_base.h          |   8 +-
 src/include/multi_array_operation.h     |   8 +-
 src/include/ranges/container_range.h    | 168 ++++++++++++------------
 src/include/ranges/multi_range.h        |   6 +-
 src/include/ranges/rbase_def.h          |   2 +-
 src/include/slice.h                     |   8 +-
 src/tests/ranges/anonymous_unit_test.cc |   2 +-
 src/tests/ranges/index_unit_test.cc     |   2 +-
 12 files changed, 107 insertions(+), 107 deletions(-)

diff --git a/src/include/functional_multi_array.h b/src/include/functional_multi_array.h
index bcd16a4..14509fd 100644
--- a/src/include/functional_multi_array.h
+++ b/src/include/functional_multi_array.h
@@ -81,7 +81,7 @@ namespace MultiArrayTools
 
 	typedef ContainerRange<T,SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	typedef MultiArray<T,SRanges...> MAType;
 	typedef T value_type;
 	
diff --git a/src/include/map_range.h b/src/include/map_range.h
index 19240dd..ed70235 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -158,7 +158,7 @@ namespace MultiArrayTools
 	
 	std::shared_ptr<OIType> outIndex() const;
 	
-	// raplace instances (in contrast to its analogon in ContainerIndex
+	// raplace instances (in contrast to its analogon in ConstContainerIndex
 	// MultiIndices CANNOT be influences be its subindices, so there is
 	// NO foreign/external controll)
 	// Do NOT share index instances between two or more MapIndex instances
diff --git a/src/include/multi_array.h b/src/include/multi_array.h
index 2e70431..0481924 100644
--- a/src/include/multi_array.h
+++ b/src/include/multi_array.h
@@ -32,7 +32,7 @@ namespace MultiArrayTools
 
 	typedef ContainerRange<T,SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	
         using MultiArrayBase<T,SRanges...>::operator[];
 	using MutableMultiArrayBase<T,SRanges...>::operator[];
diff --git a/src/include/multi_array_base.cc.h b/src/include/multi_array_base.cc.h
index ff7a2cb..3a8c4a6 100644
--- a/src/include/multi_array_base.cc.h
+++ b/src/include/multi_array_base.cc.h
@@ -69,7 +69,7 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     template <typename X>
-    const T& MultiArrayBase<T,SRanges...>::operator[](const ContainerIndex<X,typename SRanges::IndexType...>& i)
+    const T& MultiArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
     {
 	IndexType ii(*mProtoI);
 	ii = i;
@@ -207,7 +207,7 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     template <typename X>
-    T& MutableMultiArrayBase<T,SRanges...>::operator[](const ContainerIndex<X,typename SRanges::IndexType...>& i)
+    T& MutableMultiArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
     {
 	IndexType ii(*MAB::mProtoI);
 	ii = i;
diff --git a/src/include/multi_array_base.h b/src/include/multi_array_base.h
index b04ed8d..075d069 100644
--- a/src/include/multi_array_base.h
+++ b/src/include/multi_array_base.h
@@ -57,7 +57,7 @@ namespace MultiArrayTools
 
 	typedef T value_type;
 	typedef ContainerRange<T,SRanges...> CRange;
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 
     protected:
 	bool mInit = false;
@@ -79,7 +79,7 @@ namespace MultiArrayTools
 	virtual ~MultiArrayBase() = default;
 
 	template <typename X>
-	const T& operator[](const ContainerIndex<X,typename SRanges::IndexType...>& i);
+	const T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
         const T& operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const;
         
 	virtual const T& operator[](const IndexType& i) const = 0;
@@ -127,7 +127,7 @@ namespace MultiArrayTools
 
 	typedef ContainerRange<T,SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	
 	using MultiArrayBase<T,SRanges...>::operator[];
 	using MultiArrayBase<T,SRanges...>::at;
@@ -140,7 +140,7 @@ namespace MultiArrayTools
 	MutableMultiArrayBase(const typename CRange::Space& space);
 
 	template <typename X>
-	T& operator[](const ContainerIndex<X,typename SRanges::IndexType...>& i);
+	T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
         T& operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is);
         
 	virtual T& operator[](const IndexType& i) = 0;
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 2bbf4ca..01e3d48 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -411,7 +411,7 @@ namespace MultiArrayTools
 	typedef T value_type;
 	typedef OperationBase<T,ConstOperationRoot<T,Ranges...> > OT;
 	typedef ContainerRange<T,Ranges...> CRange;
-	typedef ContainerIndex<T,typename Ranges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename Ranges::IndexType...> IndexType;
 
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = true;
@@ -535,7 +535,7 @@ namespace MultiArrayTools
 	typedef T value_type;
 	typedef OperationBase<T,OperationRoot<T,Ranges...> > OT;
 	typedef ContainerRange<T,Ranges...> CRange;
-	typedef ContainerIndex<T,typename Ranges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename Ranges::IndexType...> IndexType;
 
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = true;
@@ -630,7 +630,7 @@ namespace MultiArrayTools
 	typedef T value_type;
 	typedef OperationBase<T,ParallelOperationRoot<T,Ranges...> > OT;
 	typedef ContainerRange<T,Ranges...> CRange;
-	typedef ContainerIndex<T,typename Ranges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename Ranges::IndexType...> IndexType;
 
 	static constexpr size_t SIZE = 1;
         static constexpr bool CONT = true;
@@ -715,7 +715,7 @@ namespace MultiArrayTools
 	typedef T value_type;
 	typedef OperationBase<T,OperationValue<T> > OT;
 	typedef ContainerRange<T,NullRange> CRange;
-	typedef ContainerIndex<T,NullIndex> IndexType;
+	typedef ConstContainerIndex<T,NullIndex> IndexType;
 
 	static constexpr size_t SIZE = 0;
         static constexpr bool CONT = true;
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index 35b9b17..c7f521b 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -14,13 +14,13 @@ namespace MultiArrayTools
 {
     
     template <typename T, class... Indices>
-    class ContainerIndex : public IndexInterface<ContainerIndex<T,Indices...>,
+    class ConstContainerIndex : public IndexInterface<ConstContainerIndex<T,Indices...>,
 						 std::tuple<typename Indices::MetaType...> >,
 			   public std::iterator<std::random_access_iterator_tag,T>
     {
     public:
 
-	typedef IndexInterface<ContainerIndex<T,Indices...>,
+	typedef IndexInterface<ConstContainerIndex<T,Indices...>,
 			       std::tuple<typename Indices::MetaType...> > IB;
 	typedef std::tuple<typename Indices::MetaType...>  MetaType;
 	typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
@@ -34,14 +34,14 @@ namespace MultiArrayTools
         static constexpr bool PARALLEL = std::tuple_element<0,std::tuple<Indices...>>::type::PARALLEL;
         
 	template <typename X>
-	using CIX = ContainerIndex<X,Indices...>;
+	using CIX = ConstContainerIndex<X,Indices...>;
 	
 	template <typename X>
 	friend class CIX;
 	
     private:
 	
-	ContainerIndex() = default;
+	ConstContainerIndex() = default;
 	
 	bool mNonTrivialBlocks = false;
 	bool mExternControl = false;
@@ -54,10 +54,10 @@ namespace MultiArrayTools
 	
     public:
 
-	ContainerIndex(const ContainerIndex& in) = default;	
-	ContainerIndex& operator=(const ContainerIndex& in) = default;
+	ConstContainerIndex(const ConstContainerIndex& in) = default;	
+	ConstContainerIndex& operator=(const ConstContainerIndex& in) = default;
 
-	ContainerIndex(const ContainerIndex& in, bool copy) :
+	ConstContainerIndex(const ConstContainerIndex& in, bool copy) :
 	    IB(in),
 	    mNonTrivialBlocks(in.mNonTrivialBlocks),
 	    mExternControl(false),
@@ -76,7 +76,7 @@ namespace MultiArrayTools
 		});
 	}
 	
-	ContainerIndex& copy(const ContainerIndex& in)
+	ConstContainerIndex& copy(const ConstContainerIndex& in)
 	{
 	    IB::operator=(in);
 	    mNonTrivialBlocks = in.mNonTrivialBlocks;
@@ -97,14 +97,14 @@ namespace MultiArrayTools
 	}
 	
 	template <typename X>
-	ContainerIndex& operator=(const ContainerIndex<X,Indices...>& in);
+	ConstContainerIndex& operator=(const ConstContainerIndex<X,Indices...>& in);
 	
 	template <class MRange>
-	ContainerIndex(const std::shared_ptr<MRange>& range,
+	ConstContainerIndex(const std::shared_ptr<MRange>& range,
 		       std::intptr_t objPtrNum);
 
 	template <class MRange>
-	ContainerIndex(const std::shared_ptr<MRange>& range,
+	ConstContainerIndex(const std::shared_ptr<MRange>& range,
 		       std::intptr_t objPtrNum,
 		       const std::array<size_t,sizeof...(Indices)+1>& blockSizes);
 
@@ -119,26 +119,26 @@ namespace MultiArrayTools
 
 	const IndexPack& pack() const { return mIPack; }
 	
-	ContainerIndex& sync(); // recalculate 'IB::mPos' when externalControl == true
-	ContainerIndex& operator()(const std::shared_ptr<Indices>&... inds); // control via external indices
-        ContainerIndex& operator()(const std::tuple<std::shared_ptr<Indices>...>& inds);
-	ContainerIndex& operator()(); // -> sync; just to shorten the code
+	ConstContainerIndex& sync(); // recalculate 'IB::mPos' when externalControl == true
+	ConstContainerIndex& operator()(const std::shared_ptr<Indices>&... inds); // control via external indices
+        ConstContainerIndex& operator()(const std::tuple<std::shared_ptr<Indices>...>& inds);
+	ConstContainerIndex& operator()(); // -> sync; just to shorten the code
 
 	// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
 	
 	IndexType type() const;
 	
-	ContainerIndex& operator++();
-	ContainerIndex& operator--();
+	ConstContainerIndex& operator++();
+	ConstContainerIndex& operator--();
 	
-	ContainerIndex& operator=(size_t pos);
+	ConstContainerIndex& operator=(size_t pos);
 
 	int pp(std::intptr_t idxPtrNum);
 	int mm(std::intptr_t idxPtrNum);
 
 	std::string stringMeta() const;
 	MetaType meta() const;
-	ContainerIndex& at(const MetaType& metaPos);
+	ConstContainerIndex& at(const MetaType& metaPos);
 
 	size_t dim() const;
 	bool first() const;
@@ -162,31 +162,31 @@ namespace MultiArrayTools
 	auto pifor(size_t step, Exprs exs) const;
 
 	std::intptr_t container() const;
-	ContainerIndex& format(const std::array<size_t,sizeof...(Indices)+1>& blocks);
+	ConstContainerIndex& format(const std::array<size_t,sizeof...(Indices)+1>& blocks);
 	
 	// Iterator Stuff
 	
-	ContainerIndex& setData(const T* data);
+	ConstContainerIndex& setData(const T* data);
 	
 	const T& operator*() const;
 	const T* operator->() const;
 	//T& operator*();
 	//T* operator->();
 
-	ContainerIndex operator++(int);
-	ContainerIndex operator--(int);
-	ContainerIndex& operator+=(int diff);
-	ContainerIndex& operator-=(int diff);
-	ContainerIndex operator+(int num) const;
-	ContainerIndex operator-(int num) const;
+	ConstContainerIndex operator++(int);
+	ConstContainerIndex operator--(int);
+	ConstContainerIndex& operator+=(int diff);
+	ConstContainerIndex& operator-=(int diff);
+	ConstContainerIndex operator+(int num) const;
+	ConstContainerIndex operator-(int num) const;
 
-	int operator-(const ContainerIndex& it) const;
+	int operator-(const ConstContainerIndex& it) const;
 	const T& operator[](int num) const;
 
-	bool operator<(const ContainerIndex& it) const;
-	bool operator>(const ContainerIndex& it) const;
-	bool operator<=(const ContainerIndex& it) const;
-	bool operator>=(const ContainerIndex& it) const;
+	bool operator<(const ConstContainerIndex& it) const;
+	bool operator>(const ConstContainerIndex& it) const;
+	bool operator<=(const ConstContainerIndex& it) const;
+	bool operator>=(const ConstContainerIndex& it) const;
 	
     };
     
@@ -204,14 +204,14 @@ namespace MultiArrayTools
     }
     
     /**********************
-     *   ContainerIndex   *
+     *   ConstContainerIndex   *
      **********************/
 
     template <typename T, class... Indices>
     template <class MRange>
-    ContainerIndex<T,Indices...>::ContainerIndex(const std::shared_ptr<MRange>& range,
+    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const std::shared_ptr<MRange>& range,
 						 std::intptr_t objPtrNum) :
-	IndexInterface<ContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
+	IndexInterface<ConstContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
 	mObjPtrNum(objPtrNum)
     {
 	std::get<sizeof...(Indices)>(mBlockSizes) = 1;
@@ -235,10 +235,10 @@ namespace MultiArrayTools
 
     template <typename T, class... Indices>
     template <class MRange>
-    ContainerIndex<T,Indices...>::ContainerIndex(const std::shared_ptr<MRange>& range,
+    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const std::shared_ptr<MRange>& range,
 						 std::intptr_t objPtrNum,
 						 const std::array<size_t,sizeof...(Indices)+1>& blockSizes) :
-	IndexInterface<ContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
+	IndexInterface<ConstContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
 	mObjPtrNum(objPtrNum)
     {
 	sfor_mn<sizeof...(Indices),0>
@@ -257,8 +257,8 @@ namespace MultiArrayTools
 
     template <typename T, class... Indices>
     template <typename X>
-    ContainerIndex<T,Indices...>&
-    ContainerIndex<T,Indices...>::operator=(const ContainerIndex<X,Indices...>& in)
+    ConstContainerIndex<T,Indices...>&
+    ConstContainerIndex<T,Indices...>::operator=(const ConstContainerIndex<X,Indices...>& in)
     {
 	mIPack = in.mIPack;
 	return (*this)();
@@ -266,7 +266,7 @@ namespace MultiArrayTools
 
     
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::sync()
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::sync()
     {
 	if(mExternControl){
 	    IB::mPos = sfor_m<sizeof...(Indices),0>
@@ -279,26 +279,26 @@ namespace MultiArrayTools
     
     template <typename T, class... Indices>
     template <size_t N>
-    auto ContainerIndex<T,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
+    auto ConstContainerIndex<T,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
     {
 	return *std::get<N>( mIPack );
     }
 
     template <typename T, class... Indices>
     template <size_t N>
-    auto ContainerIndex<T,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
+    auto ConstContainerIndex<T,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
     {
 	return std::get<N>( mIPack );
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()(const std::shared_ptr<Indices>&... inds)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()(const std::shared_ptr<Indices>&... inds)
     {
 	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)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& inds)
     {
 	sfor_pn<0,sizeof...(Indices)>
 	    ( [&](auto i) { std::get<i>(mIPack) = std::get<i>(inds); return 0; } );
@@ -307,16 +307,16 @@ namespace MultiArrayTools
     }    
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()()
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()()
     {
 	return sync();
     }
 
     template <typename T, class... Indices>
-    IndexType ContainerIndex<T,Indices...>::type() const { return IndexType::CONT; }
+    IndexType ConstContainerIndex<T,Indices...>::type() const { return IndexType::CONT; }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator++()
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator++()
     {
 	if(mExternControl){
 	    IB::mPos = sfor_m<sizeof...(Indices),0>
@@ -336,7 +336,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator--()
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator--()
     {
 	if(mExternControl){
 	    IB::mPos = sfor_m<sizeof...(Indices),0>
@@ -357,7 +357,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator=(size_t pos)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator=(size_t pos)
     {
 	IB::mPos = pos;
 	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, pos);
@@ -366,7 +366,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    int ContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
+    int ConstContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
     {
 	const int tmp = RangeHelper::ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos += tmp;
@@ -374,7 +374,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    int ContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
+    int ConstContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
     {
 	const int tmp = RangeHelper::mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
 	IB::mPos -= tmp;
@@ -382,13 +382,13 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    std::string ContainerIndex<T,Indices...>::stringMeta() const
+    std::string ConstContainerIndex<T,Indices...>::stringMeta() const
     {
 	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->stringMeta(IB::mPos);
     }
     
     template <typename T, class... Indices>
-    typename ContainerIndex<T,Indices...>::MetaType ContainerIndex<T,Indices...>::meta() const
+    typename ConstContainerIndex<T,Indices...>::MetaType ConstContainerIndex<T,Indices...>::meta() const
     {
 	MetaType metaTuple;
 	sfor_pn<0,sizeof...(Indices)>
@@ -397,7 +397,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::at(const MetaType& metaPos)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::at(const MetaType& metaPos)
     {
 	sfor_pn<0,sizeof...(Indices)>
 	    ( [&](auto i) { std::get<i>(mIPack)->at( std::get<i>(metaPos) ); return 0; } );
@@ -406,45 +406,45 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    size_t ContainerIndex<T,Indices...>::dim() const
+    size_t ConstContainerIndex<T,Indices...>::dim() const
     {
 	return sizeof...(Indices);
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::first() const
+    bool ConstContainerIndex<T,Indices...>::first() const
     {
 	return IB::pos() == 0;
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::last() const
+    bool ConstContainerIndex<T,Indices...>::last() const
     {
 	return IB::pos() == IB::mMax - 1;
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::sliceMode() const
+    bool ConstContainerIndex<T,Indices...>::sliceMode() const
     {
 	return mNonTrivialBlocks;
     }
 
     template <typename T, class... Indices>
-    std::shared_ptr<typename ContainerIndex<T,Indices...>::RangeType>
-    ContainerIndex<T,Indices...>::range()
+    std::shared_ptr<typename ConstContainerIndex<T,Indices...>::RangeType>
+    ConstContainerIndex<T,Indices...>::range()
     {
 	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
     }
 
     template <typename T, class... Indices>
     template <size_t N>
-    auto ContainerIndex<T,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
+    auto ConstContainerIndex<T,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
     {
 	return std::get<N>( mIPack );
     }
 
     template <typename T, class... Indices>
-    size_t ContainerIndex<T,Indices...>::getStepSize(size_t n)
+    size_t ConstContainerIndex<T,Indices...>::getStepSize(size_t n)
     {
 	if(n >= sizeof...(Indices)){
 	    assert(0);
@@ -455,33 +455,33 @@ namespace MultiArrayTools
 
     template <typename T, class... Indices>
     template <class Exprs>
-    auto ContainerIndex<T,Indices...>::ifor(size_t step, Exprs exs) const
+    auto ConstContainerIndex<T,Indices...>::ifor(size_t step, Exprs exs) const
     {
 	return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <typename T, class... Indices>
     template <class Exprs>
-    auto ContainerIndex<T,Indices...>::iforh(size_t step, Exprs exs) const
+    auto ConstContainerIndex<T,Indices...>::iforh(size_t step, Exprs exs) const
     {
 	return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <typename T, class... Indices>
     template <class Exprs>
-    auto ContainerIndex<T,Indices...>::pifor(size_t step, Exprs exs) const
+    auto ConstContainerIndex<T,Indices...>::pifor(size_t step, Exprs exs) const
     {
 	return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs);
     }
 
     template <typename T, class... Indices>
-    std::intptr_t ContainerIndex<T,Indices...>::container() const
+    std::intptr_t ConstContainerIndex<T,Indices...>::container() const
     {
 	return mObjPtrNum;
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::
     format(const std::array<size_t,sizeof...(Indices)+1>& blocks)
     {
 	mBlockSizes = blocks;
@@ -490,14 +490,14 @@ namespace MultiArrayTools
     }
     
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::setData(const T* data)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::setData(const T* data)
     {
 	mData = data;
 	return *this;
     }
 
     template <typename T, class... Indices>
-    const T& ContainerIndex<T,Indices...>::operator*() const
+    const T& ConstContainerIndex<T,Indices...>::operator*() const
     {
 	//return mMa[*this];
 	return mData[mCPos];
@@ -505,28 +505,28 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    const T* ContainerIndex<T,Indices...>::operator->() const
+    const T* ConstContainerIndex<T,Indices...>::operator->() const
     {
 	//return &mMa[*this];
 	return &mData[mCPos];
     }
     /*
     template <typename T, class... Indices>
-    T& ContainerIndex<T,Indices...>::operator*()
+    T& ConstContainerIndex<T,Indices...>::operator*()
     {
 	//return mMa[*this];
 	return mData[IB::mPos];
     }
 
     template <typename T, class... Indices>
-    T* ContainerIndex<T,Indices...>::operator->()
+    T* ConstContainerIndex<T,Indices...>::operator->()
     {
 	//return &mMa[*this];
 	return &mData[IB::mPos];
     }
     */
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator++(int)
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator++(int)
     {
 	auto tmp = *this;
 	++(*this);
@@ -534,7 +534,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator--(int)
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator--(int)
     {
 	auto tmp = *this;
 	--(*this);
@@ -542,7 +542,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator+=(int diff)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator+=(int diff)
     {
 	if(diff < 0){
 	    for(int i = 0; i != diff; ++i){
@@ -558,7 +558,7 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator-=(int diff)
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator-=(int diff)
     {
 	if(diff < 0){
 	    for(int i = 0; i != diff; ++i){
@@ -574,51 +574,51 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator+(int num) const
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator+(int num) const
     {
 	auto tmp = *this;
 	return tmp += num;
     }
 
     template <typename T, class... Indices>
-    ContainerIndex<T,Indices...> ContainerIndex<T,Indices...>::operator-(int num) const
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator-(int num) const
     {
 	auto tmp = *this;
 	return tmp -= num;
     }
 
     template <typename T, class... Indices>
-    int ContainerIndex<T,Indices...>::operator-(const ContainerIndex<T,Indices...>& it) const
+    int ConstContainerIndex<T,Indices...>::operator-(const ConstContainerIndex<T,Indices...>& it) const
     {
 	return static_cast<int>( IB::mPos ) - static_cast<int>( it.pos() );
     }
 
     template <typename T, class... Indices>
-    const T& ContainerIndex<T,Indices...>::operator[](int num) const
+    const T& ConstContainerIndex<T,Indices...>::operator[](int num) const
     {
 	return mData[IB::mPos + num];
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::operator<(const ContainerIndex<T,Indices...>& it) const
+    bool ConstContainerIndex<T,Indices...>::operator<(const ConstContainerIndex<T,Indices...>& it) const
     {
 	return IB::mPos < it.pos();
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::operator>(const ContainerIndex<T,Indices...>& it) const
+    bool ConstContainerIndex<T,Indices...>::operator>(const ConstContainerIndex<T,Indices...>& it) const
     {
 	return IB::mPos > it.pos();
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::operator<=(const ContainerIndex<T,Indices...>& it) const
+    bool ConstContainerIndex<T,Indices...>::operator<=(const ConstContainerIndex<T,Indices...>& it) const
     {
 	return IB::mPos <= it.pos();
     }
 
     template <typename T, class... Indices>
-    bool ContainerIndex<T,Indices...>::operator>=(const ContainerIndex<T,Indices...>& it) const
+    bool ConstContainerIndex<T,Indices...>::operator>=(const ConstContainerIndex<T,Indices...>& it) const
     {
 	return IB::mPos >= it.pos();
     }
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index fd3b120..929b924 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -61,7 +61,7 @@ namespace MultiArrayTools
 	//MultiIndex(const MultiIndex& in);
 	//MultiIndex& operator=(const MultiIndex& in);
 	template <typename T>
-	MultiIndex& operator=(ContainerIndex<T,Indices...>& ci);
+	MultiIndex& operator=(ConstContainerIndex<T,Indices...>& ci);
 
 	template <class MRange>
 	MultiIndex(const std::shared_ptr<MRange>& range);
@@ -81,7 +81,7 @@ namespace MultiArrayTools
 	template <size_t N>
 	size_t getBlockSize() const { return std::get<N>(mBlockSizes); }
 	
-	// raplace instances (in contrast to its analogon in ContainerIndex
+	// raplace instances (in contrast to its analogon in ConstContainerIndex
 	// MultiIndices CANNOT be influences be its subindices, so there is
 	// NO foreign/external controll)
 	// Do NOT share index instances between two or more MultiIndex instances
@@ -242,7 +242,7 @@ namespace MultiArrayTools
 
     template <class... Indices>
     template <typename T>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(ContainerIndex<T,Indices...>& ci)
+    MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(ConstContainerIndex<T,Indices...>& ci)
     {	
 	sfor_p<0,sizeof...(Indices)>
 	    ( [&](auto i) { std::get<i>(mIPack) = ci.template getPtr<i>(); return true; } );
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index 7255381..e94bc59 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -94,7 +94,7 @@ namespace MultiArrayTools
     
     // container_range.h
     template <typename T, class... Indices>
-    class ContainerIndex;
+    class ConstContainerIndex;
 
     // anonymous_range.h
     class AnonymousRangeFactory;
diff --git a/src/include/slice.h b/src/include/slice.h
index 886df4b..dc28d70 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -14,7 +14,7 @@ namespace MultiArrayTools
 
 	typedef ContainerRange<T,SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
 	using MultiArrayBase<T,SRanges...>::operator();
         using MultiArrayBase<T,SRanges...>::operator[];
@@ -57,7 +57,7 @@ namespace MultiArrayTools
 
 	typedef ContainerRange<T,SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
 	using MultiArrayBase<T,SRanges...>::operator();
 	using MutableMultiArrayBase<T,SRanges...>::operator();
@@ -104,7 +104,7 @@ namespace MultiArrayTools
     class SliceDef
     {
     public:
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
 	template <class Op>
 	static Slice<T,SRanges...> mkSlice( const typename Slice<T,SRanges...>::IndexType& ind,
@@ -137,7 +137,7 @@ namespace MultiArrayTools
     class ConstSliceDef
     {
     public:
-	typedef ContainerIndex<T,typename SRanges::IndexType...> IType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
 	template <class Op>
 	static ConstSlice<T,SRanges...> mkSlice( const typename ConstSlice<T,SRanges...>::IndexType& ind,
diff --git a/src/tests/ranges/anonymous_unit_test.cc b/src/tests/ranges/anonymous_unit_test.cc
index 4de298e..b8b91ef 100644
--- a/src/tests/ranges/anonymous_unit_test.cc
+++ b/src/tests/ranges/anonymous_unit_test.cc
@@ -52,7 +52,7 @@ namespace {
 
 	typedef ContainerRangeFactory<double,M3Range,SRange> CRF;
 	typedef CRF::oType CRange;
-	typedef ContainerIndex<double,M3Range::IndexType,SRange::IndexType> CIndex;
+	typedef ConstContainerIndex<double,M3Range::IndexType,SRange::IndexType> CIndex;
 
 	AnonymousTest()
 	{
diff --git a/src/tests/ranges/index_unit_test.cc b/src/tests/ranges/index_unit_test.cc
index 7db3aa0..f4e6004 100644
--- a/src/tests/ranges/index_unit_test.cc
+++ b/src/tests/ranges/index_unit_test.cc
@@ -90,7 +90,7 @@ namespace {
 
 	typedef ContainerRangeFactory<double,M3Range,SRange> CRF;
 	typedef CRF::oType CRange;
-	typedef ContainerIndex<double,M3Range::IndexType,SRange::IndexType> CIndex;
+	typedef ConstContainerIndex<double,M3Range::IndexType,SRange::IndexType> CIndex;
 
 	IndexTest()
 	{

From 1d882d55c405eaed2c2c71fb5bdd0fec7217258f Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 28 May 2021 19:48:27 +0200
Subject: [PATCH 32/56] ContainerRange typedef: remove template arg T + remove
 MultiRange Factory constructor for ContainerRange

---
 src/include/functional_multi_array.h    |  2 +-
 src/include/multi_array.h               |  2 +-
 src/include/multi_array_base.cc.h       |  8 ++++----
 src/include/multi_array_base.h          |  4 ++--
 src/include/multi_array_operation.h     |  8 ++++----
 src/include/ranges/container_range.h    |  2 +-
 src/include/ranges/multi_range.h        |  8 +++++---
 src/include/ranges/rbase_def.h          | 11 ++---------
 src/include/slice.h                     |  4 ++--
 src/tests/ranges/anonymous_unit_test.cc |  2 +-
 src/tests/ranges/index_unit_test.cc     |  2 +-
 11 files changed, 24 insertions(+), 29 deletions(-)

diff --git a/src/include/functional_multi_array.h b/src/include/functional_multi_array.h
index 14509fd..b2a8251 100644
--- a/src/include/functional_multi_array.h
+++ b/src/include/functional_multi_array.h
@@ -79,7 +79,7 @@ namespace MultiArrayTools
     {
     public:
 
-	typedef ContainerRange<T,SRanges...> CRange;
+	typedef ContainerRange<SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	typedef MultiArray<T,SRanges...> MAType;
diff --git a/src/include/multi_array.h b/src/include/multi_array.h
index 0481924..4fba5e9 100644
--- a/src/include/multi_array.h
+++ b/src/include/multi_array.h
@@ -30,7 +30,7 @@ namespace MultiArrayTools
     {
     public:
 
-	typedef ContainerRange<T,SRanges...> CRange;
+	typedef ContainerRange<SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	
diff --git a/src/include/multi_array_base.cc.h b/src/include/multi_array_base.cc.h
index 3a8c4a6..80b4273 100644
--- a/src/include/multi_array_base.cc.h
+++ b/src/include/multi_array_base.cc.h
@@ -54,16 +54,16 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     MultiArrayBase<T,SRanges...>::MultiArrayBase(const std::shared_ptr<SRanges>&... ranges)
     {
-	ContainerRangeFactory<T,SRanges...> crf(ranges...);
-	mRange = std::dynamic_pointer_cast<ContainerRange<T,SRanges...> >( crf.create() );
+	ContainerRangeFactory<SRanges...> crf(ranges...);
+	mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
 	mProtoI = std::make_shared<IndexType>( mRange, reinterpret_cast<std::intptr_t>(this) );
     }
 
     template <typename T, class... SRanges>
     MultiArrayBase<T,SRanges...>::MultiArrayBase(const typename CRange::Space& space)
     {
-	ContainerRangeFactory<T,SRanges...> crf(space);
-	mRange = std::dynamic_pointer_cast<ContainerRange<T,SRanges...> >( crf.create() );
+	ContainerRangeFactory<SRanges...> crf(space);
+	mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
 	mProtoI = std::make_shared<IndexType>( mRange, reinterpret_cast<std::intptr_t>(this) );
     }
 
diff --git a/src/include/multi_array_base.h b/src/include/multi_array_base.h
index 075d069..2e27abe 100644
--- a/src/include/multi_array_base.h
+++ b/src/include/multi_array_base.h
@@ -56,7 +56,7 @@ namespace MultiArrayTools
     public:
 
 	typedef T value_type;
-	typedef ContainerRange<T,SRanges...> CRange;
+	typedef ContainerRange<SRanges...> CRange;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 
     protected:
@@ -125,7 +125,7 @@ namespace MultiArrayTools
     {
     public:
 
-	typedef ContainerRange<T,SRanges...> CRange;
+	typedef ContainerRange<SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 01e3d48..f3e32b2 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -410,7 +410,7 @@ namespace MultiArrayTools
 
 	typedef T value_type;
 	typedef OperationBase<T,ConstOperationRoot<T,Ranges...> > OT;
-	typedef ContainerRange<T,Ranges...> CRange;
+	typedef ContainerRange<Ranges...> CRange;
 	typedef ConstContainerIndex<T,typename Ranges::IndexType...> IndexType;
 
 	static constexpr size_t SIZE = 1;
@@ -534,7 +534,7 @@ namespace MultiArrayTools
 
 	typedef T value_type;
 	typedef OperationBase<T,OperationRoot<T,Ranges...> > OT;
-	typedef ContainerRange<T,Ranges...> CRange;
+	typedef ContainerRange<Ranges...> CRange;
 	typedef ConstContainerIndex<T,typename Ranges::IndexType...> IndexType;
 
 	static constexpr size_t SIZE = 1;
@@ -629,7 +629,7 @@ namespace MultiArrayTools
 
 	typedef T value_type;
 	typedef OperationBase<T,ParallelOperationRoot<T,Ranges...> > OT;
-	typedef ContainerRange<T,Ranges...> CRange;
+	typedef ContainerRange<Ranges...> CRange;
 	typedef ConstContainerIndex<T,typename Ranges::IndexType...> IndexType;
 
 	static constexpr size_t SIZE = 1;
@@ -714,7 +714,7 @@ namespace MultiArrayTools
     public:
 	typedef T value_type;
 	typedef OperationBase<T,OperationValue<T> > OT;
-	typedef ContainerRange<T,NullRange> CRange;
+	typedef ContainerRange<NullRange> CRange;
 	typedef ConstContainerIndex<T,NullIndex> IndexType;
 
 	static constexpr size_t SIZE = 0;
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index c7f521b..3a81a4b 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -24,7 +24,7 @@ namespace MultiArrayTools
 			       std::tuple<typename Indices::MetaType...> > IB;
 	typedef std::tuple<typename Indices::MetaType...>  MetaType;
 	typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
-	typedef ContainerRange<T,typename Indices::RangeType...> RangeType;
+	typedef ContainerRange<typename Indices::RangeType...> RangeType;
 
 	static constexpr IndexType sType() { return IndexType::CONT; }
 	static constexpr size_t sDim() { return sizeof...(Indices); }
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 929b924..c9d81af 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -140,8 +140,8 @@ namespace MultiArrayTools
 	MultiRangeFactory(const std::shared_ptr<Ranges>&... rs);
 	MultiRangeFactory(const typename MultiRange<Ranges...>::Space& space);
 
-	template <typename T>
-	MultiRangeFactory(const std::shared_ptr<ContainerRange<T,Ranges...> >& cr);
+	//template <typename T>
+	//MultiRangeFactory(const std::shared_ptr<ContainerRange<Ranges...> >& cr);
 	
 	virtual std::shared_ptr<RangeBase> create() override;
 
@@ -504,12 +504,14 @@ namespace MultiArrayTools
 	mProd = std::shared_ptr< MultiRange<Ranges...> >( new MultiRange<Ranges...>( st ) );
     }
 
+    /*
     template <class... Ranges>
     template <typename T>
-    MultiRangeFactory<Ranges...>::MultiRangeFactory(const std::shared_ptr<ContainerRange<T,Ranges...> >& cr)
+    MultiRangeFactory<Ranges...>::MultiRangeFactory(const std::shared_ptr<ContainerRange<Ranges...> >& cr)
     {
 	mProd = std::shared_ptr< MultiRange<Ranges...> >( new MultiRange<Ranges...>( cr->space() ) );
     }
+    */
     
     template <class... Ranges>
     std::shared_ptr<RangeBase> MultiRangeFactory<Ranges...>::create()
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index e94bc59..a30891c 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -81,15 +81,11 @@ namespace MultiArrayTools
     class MultiIndex;
 
     // container_range.h
-    //template <typename T, class... Ranges>
-    //class ContainerRangeFactory;
-    template <typename T, class... Ranges>
+    template <class... Ranges>
     using ContainerRangeFactory = MultiRangeFactory<Ranges...>;
 
     // container_range.h
-    //template <typename T, class... Ranges>
-    //class ContainerRange;
-    template <typename T, class... Ranges>
+    template <class... Ranges>
     using ContainerRange = MultiRange<Ranges...>;
     
     // container_range.h
@@ -99,9 +95,6 @@ namespace MultiArrayTools
     // anonymous_range.h
     class AnonymousRangeFactory;
 
-    // anonymous_range.h
-    //class AnonymousRange;
-
     // dynamic_range.h
     class IndexWrapperBase;
 
diff --git a/src/include/slice.h b/src/include/slice.h
index dc28d70..70c1af3 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -12,7 +12,7 @@ namespace MultiArrayTools
     {
     public:
 
-	typedef ContainerRange<T,SRanges...> CRange;
+	typedef ContainerRange<SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
@@ -55,7 +55,7 @@ namespace MultiArrayTools
     {
     public:
 
-	typedef ContainerRange<T,SRanges...> CRange;
+	typedef ContainerRange<SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
diff --git a/src/tests/ranges/anonymous_unit_test.cc b/src/tests/ranges/anonymous_unit_test.cc
index b8b91ef..c2e6815 100644
--- a/src/tests/ranges/anonymous_unit_test.cc
+++ b/src/tests/ranges/anonymous_unit_test.cc
@@ -50,7 +50,7 @@ namespace {
 	typedef MultiRangeFactory<SRange,M3Range,SRange> MasterRF;
 	typedef MasterRF::oType MasterRange;
 
-	typedef ContainerRangeFactory<double,M3Range,SRange> CRF;
+	typedef ContainerRangeFactory<M3Range,SRange> CRF;
 	typedef CRF::oType CRange;
 	typedef ConstContainerIndex<double,M3Range::IndexType,SRange::IndexType> CIndex;
 
diff --git a/src/tests/ranges/index_unit_test.cc b/src/tests/ranges/index_unit_test.cc
index f4e6004..f9d81b5 100644
--- a/src/tests/ranges/index_unit_test.cc
+++ b/src/tests/ranges/index_unit_test.cc
@@ -88,7 +88,7 @@ namespace {
 	typedef MultiRangeFactory<SRange,M3Range,SRange> MasterRF;
 	typedef MasterRF::oType MasterRange;
 
-	typedef ContainerRangeFactory<double,M3Range,SRange> CRF;
+	typedef ContainerRangeFactory<M3Range,SRange> CRF;
 	typedef CRF::oType CRange;
 	typedef ConstContainerIndex<double,M3Range::IndexType,SRange::IndexType> CIndex;
 

From 98138114f758dc7b0121f1209e1dfee4565a31ba Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 28 May 2021 20:17:20 +0200
Subject: [PATCH 33/56] remove assignment ContainerIndex -> MultiIndex

---
 src/include/ranges/multi_range.h | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index c9d81af..71c765e 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -58,10 +58,6 @@ namespace MultiArrayTools
 	
 	// NO DEFAULT HERE !!!
 	// ( have to assign sub-indices (ptr!) correctly )
-	//MultiIndex(const MultiIndex& in);
-	//MultiIndex& operator=(const MultiIndex& in);
-	template <typename T>
-	MultiIndex& operator=(ConstContainerIndex<T,Indices...>& ci);
 
 	template <class MRange>
 	MultiIndex(const std::shared_ptr<MRange>& range);
@@ -140,9 +136,6 @@ namespace MultiArrayTools
 	MultiRangeFactory(const std::shared_ptr<Ranges>&... rs);
 	MultiRangeFactory(const typename MultiRange<Ranges...>::Space& space);
 
-	//template <typename T>
-	//MultiRangeFactory(const std::shared_ptr<ContainerRange<Ranges...> >& cr);
-	
 	virtual std::shared_ptr<RangeBase> create() override;
 
     private:
@@ -239,18 +232,6 @@ namespace MultiArrayTools
     /******************
      *   MultiIndex   *
      ******************/
-
-    template <class... Indices>
-    template <typename T>
-    MultiIndex<Indices...>& MultiIndex<Indices...>::operator=(ConstContainerIndex<T,Indices...>& ci)
-    {	
-	sfor_p<0,sizeof...(Indices)>
-	    ( [&](auto i) { std::get<i>(mIPack) = ci.template getPtr<i>(); return true; } );
-	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;
-    }
     
     template <class... Indices>
     template <class MRange>
@@ -504,15 +485,6 @@ namespace MultiArrayTools
 	mProd = std::shared_ptr< MultiRange<Ranges...> >( new MultiRange<Ranges...>( st ) );
     }
 
-    /*
-    template <class... Ranges>
-    template <typename T>
-    MultiRangeFactory<Ranges...>::MultiRangeFactory(const std::shared_ptr<ContainerRange<Ranges...> >& cr)
-    {
-	mProd = std::shared_ptr< MultiRange<Ranges...> >( new MultiRange<Ranges...>( cr->space() ) );
-    }
-    */
-    
     template <class... Ranges>
     std::shared_ptr<RangeBase> MultiRangeFactory<Ranges...>::create()
     {

From 63df6bbdeff222f5d467a1130bb91be00361e67f Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 28 May 2021 20:35:24 +0200
Subject: [PATCH 34/56] ranges/container_range.h -> container_index.h

---
 .../container_range.h => container_index.h}       |  7 +++++--
 src/include/mbase_def.h                           | 14 ++++++++++----
 src/include/multi_array_header.h                  |  2 +-
 src/include/ranges/rbase_def.h                    | 15 ---------------
 src/include/ranges/rpheader.h                     |  1 -
 src/tests/ranges/index_unit_test.cc               |  6 +-----
 6 files changed, 17 insertions(+), 28 deletions(-)
 rename src/include/{ranges/container_range.h => container_index.h} (99%)

diff --git a/src/include/ranges/container_range.h b/src/include/container_index.h
similarity index 99%
rename from src/include/ranges/container_range.h
rename to src/include/container_index.h
index 3a81a4b..ee3101f 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/container_index.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __container_range_h__
-#define __container_range_h__
+#ifndef __container_index_h__
+#define __container_index_h__
 
 #include <cstdlib>
 #include <tuple>
@@ -9,6 +9,9 @@
 
 #include "ranges/range_base.h"
 #include "ranges/index_base.h"
+#include "mbase_def.h"
+#include "statics/static_for.h"
+#include "ranges/range_helper.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/include/mbase_def.h b/src/include/mbase_def.h
index d97e4ae..1550c21 100644
--- a/src/include/mbase_def.h
+++ b/src/include/mbase_def.h
@@ -11,6 +11,16 @@ namespace MultiArrayTools
      *  Provided Types     *
      ***********************/
     
+    template <class... Ranges>
+    using ContainerRangeFactory = MultiRangeFactory<Ranges...>;
+
+    template <class... Ranges>
+    using ContainerRange = MultiRange<Ranges...>;
+    
+    // container_index.h
+    template <typename T, class... Indices>
+    class ConstContainerIndex;
+
     // multi_array.h
     template <typename T, class... SRanges>
     class MultiArrayBase;
@@ -27,10 +37,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     class OperationBase;
 
-    // multi_array_operation.h
-    //template <typename T>
-    //class MutableOperationBase;
-
     // multi_array_operation.h
     template <typename T, class OperationClass>
     class OperationTemplate;
diff --git a/src/include/multi_array_header.h b/src/include/multi_array_header.h
index bc306bf..f8f2903 100644
--- a/src/include/multi_array_header.h
+++ b/src/include/multi_array_header.h
@@ -4,6 +4,7 @@
 #define __multi_array_header_h__
 
 #include <cstdlib>
+#include "container_index.h"
 #include "multi_array_operation.h"
 #include "multi_array_base.h"
 #include "multi_array.h"
@@ -13,7 +14,6 @@
 #include "map_range.h"
 #include "dynamic_operation.h"
 #include "high_level_operation.h"
-//#include "expressions.h"
 
 #include "multi_array_header.cc.h"
 
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index a30891c..289b2b6 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -80,18 +80,6 @@ namespace MultiArrayTools
     template <class... Indices>
     class MultiIndex;
 
-    // container_range.h
-    template <class... Ranges>
-    using ContainerRangeFactory = MultiRangeFactory<Ranges...>;
-
-    // container_range.h
-    template <class... Ranges>
-    using ContainerRange = MultiRange<Ranges...>;
-    
-    // container_range.h
-    template <typename T, class... Indices>
-    class ConstContainerIndex;
-
     // anonymous_range.h
     class AnonymousRangeFactory;
 
@@ -103,15 +91,12 @@ namespace MultiArrayTools
     class IndexWrapper;
 
     // dynamic_range.h
-    //template <class EC>
     class DynamicIndex;
     
     // dynamic_range.h
-    //template <class EC>
     class DynamicRangeFactory;
     
     // dynamic_range.h
-    //template <class EC>
     class DynamicRange;
 
     // value_range.h
diff --git a/src/include/ranges/rpheader.h b/src/include/ranges/rpheader.h
index 4dfd831..3de270f 100644
--- a/src/include/ranges/rpheader.h
+++ b/src/include/ranges/rpheader.h
@@ -4,7 +4,6 @@
 
 #include "single_range.h"
 #include "multi_range.h"
-#include "container_range.h"
 #include "subrange.h"
 //#include "anonymous_range.h"
 
diff --git a/src/tests/ranges/index_unit_test.cc b/src/tests/ranges/index_unit_test.cc
index f9d81b5..77c24cd 100644
--- a/src/tests/ranges/index_unit_test.cc
+++ b/src/tests/ranges/index_unit_test.cc
@@ -4,11 +4,7 @@
 #include "gtest/gtest.h"
 #include <iostream>
 
-#include "ranges/rheader.h"
-//#include "expressions.h"
-//#include "ranges/dynamic_range.cc.h"
-//#include "multi_array_header.h"
-#include "ranges/ranges_header.cc.h"
+#include "multi_array_header.h"
 
 namespace MAT = MultiArrayTools;
 

From 01703dec28c37957cc8bf0398e0c4c59ec3df677 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 28 May 2021 21:20:07 +0200
Subject: [PATCH 35/56] container_index: split header -> .h .cc.h

---
 src/include/container_index.cc.h    | 447 ++++++++++++++++++++++++++
 src/include/container_index.h       | 474 +---------------------------
 src/include/multi_array_header.cc.h |   1 +
 3 files changed, 450 insertions(+), 472 deletions(-)
 create mode 100644 src/include/container_index.cc.h

diff --git a/src/include/container_index.cc.h b/src/include/container_index.cc.h
new file mode 100644
index 0000000..6c0f482
--- /dev/null
+++ b/src/include/container_index.cc.h
@@ -0,0 +1,447 @@
+
+#include "container_index.h"
+
+namespace MultiArrayTools
+{
+    
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const ConstContainerIndex& in, bool copy) :
+	IB(in),
+	mNonTrivialBlocks(in.mNonTrivialBlocks),
+	mExternControl(false),
+	mBlockSizes(in.mBlockSizes),
+	mData(in.mData),
+	mCPos(in.mCPos),
+	mObjPtrNum(in.mObjPtrNum)
+    {
+	sfor_pn<0,sizeof...(Indices)>
+	    ( [&](auto i)
+	    {
+		typedef typename std::remove_reference<decltype(*std::get<i>(mIPack))>::type
+		    SubType;
+		std::get<i>(mIPack) = std::make_shared<SubType>( in.template get<i>() ) ;
+		return true;
+	    });
+    }
+	
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::copy(const ConstContainerIndex& in)
+    {
+	IB::operator=(in);
+	mNonTrivialBlocks = in.mNonTrivialBlocks;
+	mExternControl = false;
+	mBlockSizes = in.mBlockSizes;
+	mData = in.mData;
+	mCPos = in.mCPos;
+	mObjPtrNum = in.mObjPtrNum;
+	sfor_pn<0,sizeof...(Indices)>
+	    ( [&](auto i)
+	    {
+		typedef typename std::remove_reference<decltype(*std::get<i>(mIPack))>::type
+		    SubType;
+		std::get<i>(mIPack) = std::make_shared<SubType>( in.template get<i>() ) ;
+		return true;
+	    });
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    template <class MRange>
+    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const std::shared_ptr<MRange>& range,
+						 std::intptr_t objPtrNum) :
+	IndexInterface<ConstContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
+	mObjPtrNum(objPtrNum)
+    {
+	std::get<sizeof...(Indices)>(mBlockSizes) = 1;
+	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 = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+    }
+
+    template <typename T, class... Indices>
+    template <class MRange>
+    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const std::shared_ptr<MRange>& range,
+						 std::intptr_t objPtrNum,
+						 const std::array<size_t,sizeof...(Indices)+1>& blockSizes) :
+	IndexInterface<ConstContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
+	mObjPtrNum(objPtrNum)
+    {
+	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 = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+	mNonTrivialBlocks = true;
+    }
+
+    template <typename T, class... Indices>
+    template <typename X>
+    ConstContainerIndex<T,Indices...>&
+    ConstContainerIndex<T,Indices...>::operator=(const ConstContainerIndex<X,Indices...>& in)
+    {
+	mIPack = in.mIPack;
+	return (*this)();
+    }
+
+    
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::sync()
+    {
+	if(mExternControl){
+	    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 = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+	}
+	return *this;
+    }
+    
+    template <typename T, class... Indices>
+    template <size_t N>
+    auto ConstContainerIndex<T,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
+    {
+	return *std::get<N>( mIPack );
+    }
+
+    template <typename T, class... Indices>
+    template <size_t N>
+    auto ConstContainerIndex<T,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
+    {
+	return std::get<N>( mIPack );
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()(const std::shared_ptr<Indices>&... inds)
+    {
+	return (*this)(std::make_tuple(inds...));
+    }    
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& inds)
+    {
+	sfor_pn<0,sizeof...(Indices)>
+	    ( [&](auto i) { std::get<i>(mIPack) = std::get<i>(inds); return 0; } );
+	mExternControl = true;
+	return sync();
+    }    
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()()
+    {
+	return sync();
+    }
+
+    template <typename T, class... Indices>
+    IndexType ConstContainerIndex<T,Indices...>::type() const { return IndexType::CONT; }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator++()
+    {
+	if(mExternControl){
+	    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) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.last() and i != 0) { si = 0; return true; }
+		else { ++si; return false; }
+		return false;
+	    } );
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+	++IB::mPos;
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator--()
+    {
+	if(mExternControl){
+	    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) {
+		auto& si = *std::get<i>( mIPack );
+		if(si.first() and i != 0) { si = si.max()-1; return true; }
+		else { --si; return false; }
+		return false;
+	    } );
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+	--IB::mPos;
+	return *this;
+
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator=(size_t pos)
+    {
+	IB::mPos = pos;
+	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, pos);
+	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    int ConstContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
+    {
+	const int tmp = RangeHelper::ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
+	IB::mPos += tmp;
+	return tmp;
+    }
+
+    template <typename T, class... Indices>
+    int ConstContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
+    {
+	const int tmp = RangeHelper::mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
+	IB::mPos -= tmp;
+	return tmp;
+    }
+
+    template <typename T, class... Indices>
+    std::string ConstContainerIndex<T,Indices...>::stringMeta() const
+    {
+	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->stringMeta(IB::mPos);
+    }
+    
+    template <typename T, class... Indices>
+    typename ConstContainerIndex<T,Indices...>::MetaType ConstContainerIndex<T,Indices...>::meta() const
+    {
+	MetaType metaTuple;
+	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>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::at(const MetaType& metaPos)
+    {
+	sfor_pn<0,sizeof...(Indices)>
+	    ( [&](auto i) { std::get<i>(mIPack)->at( std::get<i>(metaPos) ); return 0; } );
+	IB::mPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    size_t ConstContainerIndex<T,Indices...>::dim() const
+    {
+	return sizeof...(Indices);
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::first() const
+    {
+	return IB::pos() == 0;
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::last() const
+    {
+	return IB::pos() == IB::mMax - 1;
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::sliceMode() const
+    {
+	return mNonTrivialBlocks;
+    }
+
+    template <typename T, class... Indices>
+    std::shared_ptr<typename ConstContainerIndex<T,Indices...>::RangeType>
+    ConstContainerIndex<T,Indices...>::range()
+    {
+	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
+    }
+
+    template <typename T, class... Indices>
+    template <size_t N>
+    auto ConstContainerIndex<T,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
+    {
+	return std::get<N>( mIPack );
+    }
+
+    template <typename T, class... Indices>
+    size_t ConstContainerIndex<T,Indices...>::getStepSize(size_t n)
+    {
+	if(n >= sizeof...(Indices)){
+	    assert(0);
+	    // throw !!
+	}
+	return mBlockSizes[n+1];
+    }
+
+    template <typename T, class... Indices>
+    template <class Exprs>
+    auto ConstContainerIndex<T,Indices...>::ifor(size_t step, Exprs exs) const
+    {
+	return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs);
+    }
+
+    template <typename T, class... Indices>
+    template <class Exprs>
+    auto ConstContainerIndex<T,Indices...>::iforh(size_t step, Exprs exs) const
+    {
+	return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs);
+    }
+
+    template <typename T, class... Indices>
+    template <class Exprs>
+    auto ConstContainerIndex<T,Indices...>::pifor(size_t step, Exprs exs) const
+    {
+	return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs);
+    }
+
+    template <typename T, class... Indices>
+    std::intptr_t ConstContainerIndex<T,Indices...>::container() const
+    {
+	return mObjPtrNum;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::
+    format(const std::array<size_t,sizeof...(Indices)+1>& blocks)
+    {
+	mBlockSizes = blocks;
+        mNonTrivialBlocks = true;
+	return *this;
+    }
+    
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::setData(const T* data)
+    {
+	mData = data;
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    const T& ConstContainerIndex<T,Indices...>::operator*() const
+    {
+	return mData[mCPos];
+    }
+
+    template <typename T, class... Indices>
+    const T* ConstContainerIndex<T,Indices...>::operator->() const
+    {
+	return &mData[mCPos];
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator++(int)
+    {
+	auto tmp = *this;
+	++(*this);
+	return tmp;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator--(int)
+    {
+	auto tmp = *this;
+	--(*this);
+	return tmp;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator+=(int diff)
+    {
+	if(diff < 0){
+	    for(int i = 0; i != diff; ++i){
+		(*this)--;
+	    }
+	}
+	else {
+	    for(int i = 0; i != diff; ++i){
+		(*this)++;
+	    }
+	}
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator-=(int diff)
+    {
+	if(diff < 0){
+	    for(int i = 0; i != diff; ++i){
+		(*this)++;
+	    }
+	}
+	else {
+	    for(int i = 0; i != diff; ++i){
+		(*this)--;
+	    }
+	}
+	return *this;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator+(int num) const
+    {
+	auto tmp = *this;
+	return tmp += num;
+    }
+
+    template <typename T, class... Indices>
+    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator-(int num) const
+    {
+	auto tmp = *this;
+	return tmp -= num;
+    }
+
+    template <typename T, class... Indices>
+    int ConstContainerIndex<T,Indices...>::operator-(const ConstContainerIndex<T,Indices...>& it) const
+    {
+	return static_cast<int>( IB::mPos ) - static_cast<int>( it.pos() );
+    }
+
+    template <typename T, class... Indices>
+    const T& ConstContainerIndex<T,Indices...>::operator[](int num) const
+    {
+	return mData[IB::mPos + num];
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::operator<(const ConstContainerIndex<T,Indices...>& it) const
+    {
+	return IB::mPos < it.pos();
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::operator>(const ConstContainerIndex<T,Indices...>& it) const
+    {
+	return IB::mPos > it.pos();
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::operator<=(const ConstContainerIndex<T,Indices...>& it) const
+    {
+	return IB::mPos <= it.pos();
+    }
+
+    template <typename T, class... Indices>
+    bool ConstContainerIndex<T,Indices...>::operator>=(const ConstContainerIndex<T,Indices...>& it) const
+    {
+	return IB::mPos >= it.pos();
+    }
+
+} // namespace MultiArrayTools
diff --git a/src/include/container_index.h b/src/include/container_index.h
index ee3101f..876caf3 100644
--- a/src/include/container_index.h
+++ b/src/include/container_index.h
@@ -52,7 +52,6 @@ namespace MultiArrayTools
 	std::array<size_t,sizeof...(Indices)+1> mBlockSizes; 
 	const T* mData = nullptr;
 	size_t mCPos;
-	//const MultiArrayBase<T,typename Indices::RangeType...>* mMa = nullptr;
 	std::intptr_t mObjPtrNum;
 	
     public:
@@ -60,44 +59,9 @@ namespace MultiArrayTools
 	ConstContainerIndex(const ConstContainerIndex& in) = default;	
 	ConstContainerIndex& operator=(const ConstContainerIndex& in) = default;
 
-	ConstContainerIndex(const ConstContainerIndex& in, bool copy) :
-	    IB(in),
-	    mNonTrivialBlocks(in.mNonTrivialBlocks),
-	    mExternControl(false),
-	    mBlockSizes(in.mBlockSizes),
-	    mData(in.mData),
-	    mCPos(in.mCPos),
-	    mObjPtrNum(in.mObjPtrNum)
-	{
-	    sfor_pn<0,sizeof...(Indices)>
-		( [&](auto i)
-		{
-		    typedef typename std::remove_reference<decltype(*std::get<i>(mIPack))>::type
-			SubType;
-		    std::get<i>(mIPack) = std::make_shared<SubType>( in.template get<i>() ) ;
-		    return true;
-		});
-	}
+	ConstContainerIndex(const ConstContainerIndex& in, bool copy);
 	
-	ConstContainerIndex& copy(const ConstContainerIndex& in)
-	{
-	    IB::operator=(in);
-	    mNonTrivialBlocks = in.mNonTrivialBlocks;
-	    mExternControl = false;
-	    mBlockSizes = in.mBlockSizes;
-	    mData = in.mData;
-	    mCPos = in.mCPos;
-	    mObjPtrNum = in.mObjPtrNum;
-	    sfor_pn<0,sizeof...(Indices)>
-		( [&](auto i)
-		{
-		    typedef typename std::remove_reference<decltype(*std::get<i>(mIPack))>::type
-			SubType;
-		    std::get<i>(mIPack) = std::make_shared<SubType>( in.template get<i>() ) ;
-		    return true;
-		});
-	    return *this;
-	}
+	ConstContainerIndex& copy(const ConstContainerIndex& in);
 	
 	template <typename X>
 	ConstContainerIndex& operator=(const ConstContainerIndex<X,Indices...>& in);
@@ -195,438 +159,4 @@ namespace MultiArrayTools
     
 } // end namespace MultiArrayTools
 
-/* ========================= *
- * ---   TEMPLATE CODE   --- *
- * ========================= */
-
-namespace MultiArrayTools
-{
-    namespace
-    {
-	using namespace MultiArrayHelper;
-    }
-    
-    /**********************
-     *   ConstContainerIndex   *
-     **********************/
-
-    template <typename T, class... Indices>
-    template <class MRange>
-    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const std::shared_ptr<MRange>& range,
-						 std::intptr_t objPtrNum) :
-	IndexInterface<ConstContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
-	mObjPtrNum(objPtrNum)
-    {
-	std::get<sizeof...(Indices)>(mBlockSizes) = 1;
-	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 = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-    }
-
-    template <typename T, class... Indices>
-    template <class MRange>
-    ConstContainerIndex<T,Indices...>::ConstContainerIndex(const std::shared_ptr<MRange>& range,
-						 std::intptr_t objPtrNum,
-						 const std::array<size_t,sizeof...(Indices)+1>& blockSizes) :
-	IndexInterface<ConstContainerIndex<T,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0),
-	mObjPtrNum(objPtrNum)
-    {
-	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 = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-	mNonTrivialBlocks = true;
-    }
-
-    template <typename T, class... Indices>
-    template <typename X>
-    ConstContainerIndex<T,Indices...>&
-    ConstContainerIndex<T,Indices...>::operator=(const ConstContainerIndex<X,Indices...>& in)
-    {
-	mIPack = in.mIPack;
-	return (*this)();
-    }
-
-    
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::sync()
-    {
-	if(mExternControl){
-	    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 = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-	}
-	return *this;
-    }
-    
-    template <typename T, class... Indices>
-    template <size_t N>
-    auto ConstContainerIndex<T,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
-    {
-	return *std::get<N>( mIPack );
-    }
-
-    template <typename T, class... Indices>
-    template <size_t N>
-    auto ConstContainerIndex<T,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
-    {
-	return std::get<N>( mIPack );
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()(const std::shared_ptr<Indices>&... inds)
-    {
-	return (*this)(std::make_tuple(inds...));
-    }    
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& inds)
-    {
-	sfor_pn<0,sizeof...(Indices)>
-	    ( [&](auto i) { std::get<i>(mIPack) = std::get<i>(inds); return 0; } );
-	mExternControl = true;
-	return sync();
-    }    
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator()()
-    {
-	return sync();
-    }
-
-    template <typename T, class... Indices>
-    IndexType ConstContainerIndex<T,Indices...>::type() const { return IndexType::CONT; }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator++()
-    {
-	if(mExternControl){
-	    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) {
-		auto& si = *std::get<i>( mIPack );
-		if(si.last() and i != 0) { si = 0; return true; }
-		else { ++si; return false; }
-		return false;
-	    } );
-	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-	++IB::mPos;
-	return *this;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator--()
-    {
-	if(mExternControl){
-	    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) {
-		auto& si = *std::get<i>( mIPack );
-		if(si.first() and i != 0) { si = si.max()-1; return true; }
-		else { --si; return false; }
-		return false;
-	    } );
-	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-	--IB::mPos;
-	return *this;
-
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator=(size_t pos)
-    {
-	IB::mPos = pos;
-	RangeHelper::setIndexPack<sizeof...(Indices)-1>(mIPack, pos);
-	mCPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-	return *this;
-    }
-
-    template <typename T, class... Indices>
-    int ConstContainerIndex<T,Indices...>::pp(std::intptr_t idxPtrNum)
-    {
-	const int tmp = RangeHelper::ppx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
-	IB::mPos += tmp;
-	return tmp;
-    }
-
-    template <typename T, class... Indices>
-    int ConstContainerIndex<T,Indices...>::mm(std::intptr_t idxPtrNum)
-    {
-	const int tmp = RangeHelper::mmx<sizeof...(Indices)-1>(mIPack, mBlockSizes, idxPtrNum);
-	IB::mPos -= tmp;
-	return tmp;
-    }
-
-    template <typename T, class... Indices>
-    std::string ConstContainerIndex<T,Indices...>::stringMeta() const
-    {
-	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->stringMeta(IB::mPos);
-    }
-    
-    template <typename T, class... Indices>
-    typename ConstContainerIndex<T,Indices...>::MetaType ConstContainerIndex<T,Indices...>::meta() const
-    {
-	MetaType metaTuple;
-	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>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::at(const MetaType& metaPos)
-    {
-	sfor_pn<0,sizeof...(Indices)>
-	    ( [&](auto i) { std::get<i>(mIPack)->at( std::get<i>(metaPos) ); return 0; } );
-	IB::mPos = RangeHelper::makePos<sizeof...(Indices)-1>(mIPack, mBlockSizes);
-	return *this;
-    }
-
-    template <typename T, class... Indices>
-    size_t ConstContainerIndex<T,Indices...>::dim() const
-    {
-	return sizeof...(Indices);
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::first() const
-    {
-	return IB::pos() == 0;
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::last() const
-    {
-	return IB::pos() == IB::mMax - 1;
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::sliceMode() const
-    {
-	return mNonTrivialBlocks;
-    }
-
-    template <typename T, class... Indices>
-    std::shared_ptr<typename ConstContainerIndex<T,Indices...>::RangeType>
-    ConstContainerIndex<T,Indices...>::range()
-    {
-	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
-    }
-
-    template <typename T, class... Indices>
-    template <size_t N>
-    auto ConstContainerIndex<T,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
-    {
-	return std::get<N>( mIPack );
-    }
-
-    template <typename T, class... Indices>
-    size_t ConstContainerIndex<T,Indices...>::getStepSize(size_t n)
-    {
-	if(n >= sizeof...(Indices)){
-	    assert(0);
-	    // throw !!
-	}
-	return mBlockSizes[n+1];
-    }
-
-    template <typename T, class... Indices>
-    template <class Exprs>
-    auto ConstContainerIndex<T,Indices...>::ifor(size_t step, Exprs exs) const
-    {
-	return RangeHelper::mkFor<0>(step, mIPack, mBlockSizes, exs);
-    }
-
-    template <typename T, class... Indices>
-    template <class Exprs>
-    auto ConstContainerIndex<T,Indices...>::iforh(size_t step, Exprs exs) const
-    {
-	return RangeHelper::mkForh<0>(step, mIPack, mBlockSizes, exs);
-    }
-
-    template <typename T, class... Indices>
-    template <class Exprs>
-    auto ConstContainerIndex<T,Indices...>::pifor(size_t step, Exprs exs) const
-    {
-	return RangeHelper::mkPFor<0>(step, mIPack, mBlockSizes, exs);
-    }
-
-    template <typename T, class... Indices>
-    std::intptr_t ConstContainerIndex<T,Indices...>::container() const
-    {
-	return mObjPtrNum;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::
-    format(const std::array<size_t,sizeof...(Indices)+1>& blocks)
-    {
-	mBlockSizes = blocks;
-        mNonTrivialBlocks = true;
-	return *this;
-    }
-    
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::setData(const T* data)
-    {
-	mData = data;
-	return *this;
-    }
-
-    template <typename T, class... Indices>
-    const T& ConstContainerIndex<T,Indices...>::operator*() const
-    {
-	//return mMa[*this];
-	return mData[mCPos];
-	//return mData[IB::mPos];
-    }
-
-    template <typename T, class... Indices>
-    const T* ConstContainerIndex<T,Indices...>::operator->() const
-    {
-	//return &mMa[*this];
-	return &mData[mCPos];
-    }
-    /*
-    template <typename T, class... Indices>
-    T& ConstContainerIndex<T,Indices...>::operator*()
-    {
-	//return mMa[*this];
-	return mData[IB::mPos];
-    }
-
-    template <typename T, class... Indices>
-    T* ConstContainerIndex<T,Indices...>::operator->()
-    {
-	//return &mMa[*this];
-	return &mData[IB::mPos];
-    }
-    */
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator++(int)
-    {
-	auto tmp = *this;
-	++(*this);
-	return tmp;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator--(int)
-    {
-	auto tmp = *this;
-	--(*this);
-	return tmp;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator+=(int diff)
-    {
-	if(diff < 0){
-	    for(int i = 0; i != diff; ++i){
-		(*this)--;
-	    }
-	}
-	else {
-	    for(int i = 0; i != diff; ++i){
-		(*this)++;
-	    }
-	}
-	return *this;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...>& ConstContainerIndex<T,Indices...>::operator-=(int diff)
-    {
-	if(diff < 0){
-	    for(int i = 0; i != diff; ++i){
-		(*this)++;
-	    }
-	}
-	else {
-	    for(int i = 0; i != diff; ++i){
-		(*this)--;
-	    }
-	}
-	return *this;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator+(int num) const
-    {
-	auto tmp = *this;
-	return tmp += num;
-    }
-
-    template <typename T, class... Indices>
-    ConstContainerIndex<T,Indices...> ConstContainerIndex<T,Indices...>::operator-(int num) const
-    {
-	auto tmp = *this;
-	return tmp -= num;
-    }
-
-    template <typename T, class... Indices>
-    int ConstContainerIndex<T,Indices...>::operator-(const ConstContainerIndex<T,Indices...>& it) const
-    {
-	return static_cast<int>( IB::mPos ) - static_cast<int>( it.pos() );
-    }
-
-    template <typename T, class... Indices>
-    const T& ConstContainerIndex<T,Indices...>::operator[](int num) const
-    {
-	return mData[IB::mPos + num];
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::operator<(const ConstContainerIndex<T,Indices...>& it) const
-    {
-	return IB::mPos < it.pos();
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::operator>(const ConstContainerIndex<T,Indices...>& it) const
-    {
-	return IB::mPos > it.pos();
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::operator<=(const ConstContainerIndex<T,Indices...>& it) const
-    {
-	return IB::mPos <= it.pos();
-    }
-
-    template <typename T, class... Indices>
-    bool ConstContainerIndex<T,Indices...>::operator>=(const ConstContainerIndex<T,Indices...>& it) const
-    {
-	return IB::mPos >= it.pos();
-    }
-
-} // end namespace MultiArrayTools
-
-
 #endif
diff --git a/src/include/multi_array_header.cc.h b/src/include/multi_array_header.cc.h
index 78663a4..1149d19 100644
--- a/src/include/multi_array_header.cc.h
+++ b/src/include/multi_array_header.cc.h
@@ -1,6 +1,7 @@
 
 #include "ranges/ranges_header.cc.h"
 
+#include "container_index.cc.h"
 #include "multi_array_operation.cc.h"
 #include "functional_multi_array.cc.h"
 #include "helper_tools.cc.h"

From 53362be49946acc73d613fd62a95eaeb0d9e843b Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sat, 29 May 2021 00:03:48 +0200
Subject: [PATCH 36/56] two container indices (one const)

---
 src/include/container_index.cc.h  |  17 +---
 src/include/container_index.h     | 163 ++++++++++++++++++++++++++++--
 src/include/multi_array.cc.h      |  46 +--------
 src/include/multi_array_base.cc.h |  75 +++++++-------
 src/include/multi_array_base.h    |  35 +++----
 src/tests/ma_unit_test.cc         |  10 +-
 6 files changed, 218 insertions(+), 128 deletions(-)

diff --git a/src/include/container_index.cc.h b/src/include/container_index.cc.h
index 6c0f482..1e8c333 100644
--- a/src/include/container_index.cc.h
+++ b/src/include/container_index.cc.h
@@ -11,8 +11,8 @@ namespace MultiArrayTools
 	mExternControl(false),
 	mBlockSizes(in.mBlockSizes),
 	mData(in.mData),
-	mCPos(in.mCPos),
-	mObjPtrNum(in.mObjPtrNum)
+	mObjPtrNum(in.mObjPtrNum),
+	mCPos(in.mCPos)
     {
 	sfor_pn<0,sizeof...(Indices)>
 	    ( [&](auto i)
@@ -32,8 +32,8 @@ namespace MultiArrayTools
 	mExternControl = false;
 	mBlockSizes = in.mBlockSizes;
 	mData = in.mData;
-	mCPos = in.mCPos;
 	mObjPtrNum = in.mObjPtrNum;
+	mCPos = in.mCPos;
 	sfor_pn<0,sizeof...(Indices)>
 	    ( [&](auto i)
 	    {
@@ -117,14 +117,14 @@ namespace MultiArrayTools
     
     template <typename T, class... Indices>
     template <size_t N>
-    auto ConstContainerIndex<T,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
+    auto& ConstContainerIndex<T,Indices...>::get() const
     {
 	return *std::get<N>( mIPack );
     }
 
     template <typename T, class... Indices>
     template <size_t N>
-    auto ConstContainerIndex<T,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
+    auto ConstContainerIndex<T,Indices...>::getPtr() const
     {
 	return std::get<N>( mIPack );
     }
@@ -274,13 +274,6 @@ namespace MultiArrayTools
 	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
     }
 
-    template <typename T, class... Indices>
-    template <size_t N>
-    auto ConstContainerIndex<T,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
-    {
-	return std::get<N>( mIPack );
-    }
-
     template <typename T, class... Indices>
     size_t ConstContainerIndex<T,Indices...>::getStepSize(size_t n)
     {
diff --git a/src/include/container_index.h b/src/include/container_index.h
index 876caf3..0dec151 100644
--- a/src/include/container_index.h
+++ b/src/include/container_index.h
@@ -18,8 +18,8 @@ namespace MultiArrayTools
     
     template <typename T, class... Indices>
     class ConstContainerIndex : public IndexInterface<ConstContainerIndex<T,Indices...>,
-						 std::tuple<typename Indices::MetaType...> >,
-			   public std::iterator<std::random_access_iterator_tag,T>
+						      std::tuple<typename Indices::MetaType...> >,
+				public std::iterator<std::random_access_iterator_tag,T>
     {
     public:
 
@@ -51,8 +51,10 @@ namespace MultiArrayTools
 	IndexPack mIPack;
 	std::array<size_t,sizeof...(Indices)+1> mBlockSizes; 
 	const T* mData = nullptr;
-	size_t mCPos;
 	std::intptr_t mObjPtrNum;
+
+    protected:
+	size_t mCPos;
 	
     public:
 
@@ -75,11 +77,6 @@ namespace MultiArrayTools
 		       std::intptr_t objPtrNum,
 		       const std::array<size_t,sizeof...(Indices)+1>& blockSizes);
 
-	template <size_t N>
-	auto get() const -> decltype( *std::get<N>( mIPack ) )&;
-
-	template <size_t N>
-	auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;
 
 	template <size_t N>
 	size_t getBlockSize() const { return std::get<N>(mBlockSizes); }
@@ -115,7 +112,10 @@ namespace MultiArrayTools
 	std::shared_ptr<RangeType> range();
 	
 	template <size_t N>
-	auto getPtr() -> decltype( std::get<N>( mIPack ) )&;
+	auto& get() const;
+
+	template <size_t N>
+	auto getPtr() const;
 
 	size_t getStepSize(size_t n);
 
@@ -157,6 +157,151 @@ namespace MultiArrayTools
 	
     };
     
+    template <typename T, class... Indices>
+    class ContainerIndex : public ConstContainerIndex<T,Indices...>
+    {
+    public:
+
+	typedef ConstContainerIndex<T,Indices...> CCI;
+	typedef CCI IB;
+	typedef typename CCI::MetaType MetaType;
+	typedef typename CCI::IndexPack IndexPack;
+	typedef typename CCI::RangeType RangeType;
+
+	static constexpr IndexType sType() { return CCI::sType(); }
+	static constexpr size_t sDim() { return CCI::sDim(); }
+	static constexpr size_t totalDim() { return CCI::totalDim(); }
+
+	static constexpr SpaceType STYPE = CCI::STYPE;
+        static constexpr bool PARALLEL = CCI::PARALLEL;
+        
+	template <typename X>
+	using CIX = ContainerIndex<X,Indices...>;
+	
+	template <typename X>
+	friend class CIX;
+	
+    private:
+	
+	ContainerIndex() = default;
+	
+	T* mMData = nullptr;
+	
+    public:
+
+	ContainerIndex(const ContainerIndex& in) = default;	
+	ContainerIndex& operator=(const ContainerIndex& in) = default;
+
+	ContainerIndex(const ContainerIndex& in, bool copy) : CCI(in,copy)
+	{ mMData = in.mMData; }
+
+	ContainerIndex(const ConstContainerIndex<T,Indices...>& in, T* data) : CCI(in)
+	{ mMData = data; }
+
+	ContainerIndex(const ConstContainerIndex<T,Indices...>& in, T* data, bool copy) :
+	    CCI(in,copy)
+	{ mMData = data; }
+
+	ContainerIndex& copy(const ContainerIndex& in)
+	{ CCI::copy(in); mMData = in.mMData; }
+	
+	template <typename X>
+	ContainerIndex& operator=(const ContainerIndex<X,Indices...>& in)
+	{ CCI::operator=(in); return *this; }
+	
+	template <class MRange>
+	ContainerIndex(const std::shared_ptr<MRange>& range,
+		       std::intptr_t objPtrNum) : CCI(range, objPtrNum) {}
+
+	template <class MRange>
+	ContainerIndex(const std::shared_ptr<MRange>& range,
+		       std::intptr_t objPtrNum,
+		       const std::array<size_t,sizeof...(Indices)+1>& blockSizes)
+	    : CCI(range, objPtrNum, blockSizes) {}
+
+
+	template <size_t N>
+	size_t getBlockSize() const { return CCI::template getBlockSize<N>(); }
+
+	const IndexPack& pack() const { CCI::pack(); return *this; }
+	
+	ContainerIndex& sync() { return CCI::sync(); return *this; }
+	ContainerIndex& operator()(const std::shared_ptr<Indices>&... inds)
+	{ CCI::operator()(inds...); return *this; }
+        ContainerIndex& operator()(const std::tuple<std::shared_ptr<Indices>...>& inds)
+	{ CCI::operator()(inds); return *this; }
+	ContainerIndex& operator()() { CCI::operator()(); return *this; }
+
+	// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
+	
+	IndexType type() const { return CCI::type(); }
+	
+	ContainerIndex& operator++() { CCI::operator++(); return *this; }
+	ContainerIndex& operator--() { CCI::operator--(); return *this; }
+	
+	ContainerIndex& operator=(size_t pos) { CCI::operator=(pos); return *this; }
+
+	int pp(std::intptr_t idxPtrNum) { return CCI::pp(idxPtrNum); }
+	int mm(std::intptr_t idxPtrNum) { return CCI::mm(idxPtrNum); }
+
+	std::string stringMeta() const { return CCI::stringMeta; }
+	MetaType meta() const { return CCI::meta(); }
+	ContainerIndex& at(const MetaType& metaPos) { CCI::at(metaPos); return *this; }
+
+	size_t dim() const { return CCI::dim(); }
+	bool first() const { return CCI::first(); }
+	bool last() const { return CCI::last(); }
+	bool sliceMode() const { return CCI::sliceMode(); }
+	
+	std::shared_ptr<RangeType> range() { return CCI::range(); }
+	
+	template <size_t N>
+	auto& get() const { return CCI::template get<N>(); }
+
+	template <size_t N>
+	auto getPtr() const { return CCI::template getPtr<N>(); }
+
+	size_t getStepSize(size_t n) { return getStepSize(n); }
+
+	template <class Exprs>
+	auto ifor(size_t step, Exprs exs) const { return CCI::ifor(step, exs); }
+
+	template <class Exprs>
+	auto iforh(size_t step, Exprs exs) const { return CCI::iforh(step, exs); }
+
+        template <class Exprs>
+	auto pifor(size_t step, Exprs exs) const { return CCI::pifor(step, exs); }
+
+	std::intptr_t container() const { return CCI::container(); }
+	ContainerIndex& format(const std::array<size_t,sizeof...(Indices)+1>& blocks)
+	{ CCI::format(blocks); return *this; }
+	
+	// Iterator Stuff
+	
+	ContainerIndex& setData(T* data) { CCI::setData(data); mMData = data; return *this; }
+	
+	const T& operator*() const { return CCI::operator*(); }
+	const T* operator->() const { return CCI::operator->(); }
+	T& operator*() { return mMData[CCI::mCPos]; }
+	T* operator->() { return &mMData[CCI::mCPos]; }
+
+	ContainerIndex operator++(int) { auto tmp = *this; ++(*this); return tmp; }
+	ContainerIndex operator--(int) { auto tmp = *this; --(*this); return tmp; }
+	ContainerIndex& operator+=(int diff) { CCI::operator+=(diff); return *this; }
+	ContainerIndex& operator-=(int diff) { CCI::operator-=(diff); return *this; }
+	ContainerIndex operator+(int num) const { CCI::operator+(num); return *this; }
+	ContainerIndex operator-(int num) const { CCI::operator-(num); return *this; }
+
+	int operator-(const ContainerIndex& it) const { return CCI::operator-(it); }
+	const T& operator[](int num) const { return CCI::operator[](num); }
+
+	bool operator<(const ContainerIndex& it) const { return CCI::operator<(it); }
+	bool operator>(const ContainerIndex& it) const { return CCI::operator>(it); }
+	bool operator<=(const ContainerIndex& it) const { return CCI::operator<=(it); }
+	bool operator>=(const ContainerIndex& it) const { return CCI::operator>=(it); }
+	
+    };
+
 } // end namespace MultiArrayTools
 
 #endif
diff --git a/src/include/multi_array.cc.h b/src/include/multi_array.cc.h
index 130a038..592255d 100644
--- a/src/include/multi_array.cc.h
+++ b/src/include/multi_array.cc.h
@@ -95,36 +95,6 @@ namespace MultiArrayTools
 	MAB::mInit = true;
         ama.mInit = false;
     }
-    
-    /*
-    template <typename T, class... SRanges>
-    template <class Range2, class Range3>
-    MultiArray<T,SRanges...>::MultiArray(const MultiArray<MultiArray<T,Range2>,Range3> in) :
-	MutableMultiArrayBase<T,SRanges...>(merge(in.range(), in[ in.beginIndex() ].range()))
-	// assert that Range2 has always same extension
-    {
-	MAB::mInit = true;
-	mCont.clear();
-	for(auto i = in.beginIndex(); i != in.endIndex(); ++i){
-	    mCont.insert(mCont.end(), in[i].mCont.begin(), in[i].mCont.end());
-	}
-	assert(mCont.size() == MAB::mRange->size());
-    }
-    */
-    /*
-    template <typename T, class... SRanges>
-    template <class Range2, class Range3>
-    MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator=(const MultiArray<MultiArray<T,Range2>,Range3> in)
-    {
-	MAB::mRange.reset(new Range(merge(in.range(), in[ in.beginIndex() ].range())));
-	// assert that Range2 has always same extension
-	mCont.clear();
-	for(auto i = in.beginIndex(); i != in.endIndex(); ++i){
-	    mCont.insert(mCont.end(), in[i].mCont.begin(), in[i].mCont.end());
-	}
-	assert(mCont.size() == MAB::mRange->size());
-	return *this;
-	} */   
 
     template <typename T, class... SRanges>
     T& MultiArray<T,SRanges...>::operator[](const IndexType& i)
@@ -141,13 +111,13 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     T& MultiArray<T,SRanges...>::at(const typename IndexType::MetaType& meta)
     {
-	return mCont[ MAB::beginIndex().at(meta).pos() ];
+	return mCont[ MAB::cbegin().at(meta).pos() ];
     }
 
     template <typename T, class... SRanges>
     const T& MultiArray<T,SRanges...>::at(const typename IndexType::MetaType& meta) const
     {
-	return mCont[ MAB::beginIndex().at(meta).pos() ];
+	return mCont[ MAB::cbegin().at(meta).pos() ];
     }
 	
     template <typename T, class... SRanges>
@@ -220,17 +190,6 @@ namespace MultiArrayTools
 	}
     }
 
-    /*
-    template <typename T, class... SRanges>
-    std::shared_ptr<MultiArrayBase<T,AnonymousRange> > MultiArray<T,SRanges...>::anonymousMove()
-    {
-	AnonymousRangeFactory arf(MAB::mRange->space());
-	MAB::mInit = false;
-	return std::make_shared<MultiArray<T,AnonymousRange> >
-	    ( std::dynamic_pointer_cast<AnonymousRange>( arf.create() ),
-	      std::move(mCont) );
-    }	
-    */
     template <typename T, class... SRanges>
     MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator=(const T& in)
     {
@@ -270,7 +229,6 @@ namespace MultiArrayTools
             for(size_t i = 0; i != mCont.size(); ++i){
                 mCont[i] -= in.mCont[i];
             }
-//std::transform(mCont.begin(), mCont.end(), in.mCont.begin(), mCont.begin(), std::minus<T>());
 	}
 	return *this;
     }
diff --git a/src/include/multi_array_base.cc.h b/src/include/multi_array_base.cc.h
index 80b4273..91b6993 100644
--- a/src/include/multi_array_base.cc.h
+++ b/src/include/multi_array_base.cc.h
@@ -91,38 +91,30 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::IndexType MultiArrayBase<T,SRanges...>::begin() const
+    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::begin() const
     {
-	IndexType i(*mProtoI,true);
-	i = 0;
-	return i.setData(data());
+	return cbegin();
     }
     
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::IndexType MultiArrayBase<T,SRanges...>::end() const
+    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::end() const
     {
-	IndexType i(*mProtoI,true);
-	i = i.max();
-	//i = mRange->size();
-	return i.setData(data());
-    }
-    
-    template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::IndexType
-    MultiArrayBase<T,SRanges...>::beginIndex() const
-    {
-	IndexType i(*mProtoI,true);
-	i = 0;
-	return i.setData(data());
+	return end();
     }
 
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::IndexType
-    MultiArrayBase<T,SRanges...>::endIndex() const
+    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::cbegin() const
     {
-	IndexType i(*mProtoI,true);
+	CIndexType i(*mProtoI,true);
+	i = 0;
+	return i.setData(data());
+    }
+    
+    template <typename T, class... SRanges>
+    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::cend() const
+    {
+	CIndexType i(*mProtoI,true);
 	i = i.max();
-	//i = mRange->size();
 	return i.setData(data());
     }
 
@@ -148,7 +140,7 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     ConstOperationRoot<T,SRanges...>
-    MultiArrayBase<T,SRanges...>::op(const std::shared_ptr<IndexType>& ind) const
+    MultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
     {
 	return ConstOperationRoot<T,SRanges...>(data(), *ind);
     }
@@ -189,21 +181,6 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const typename CRange::Space& space) :
 	MultiArrayBase<T,SRanges...>(space) {}
-    /*
-    template <typename T, class... SRanges>
-    typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::begin()
-    {
-	auto i = mRange->begin();
-	return i.setData(data());
-    }
-
-    template <typename T, class... SRanges>
-    typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::end()
-    {
-	auto i = mRange->end();
-	return i.setData(data());
-    }
-    */
 
     template <typename T, class... SRanges>
     template <typename X>
@@ -217,11 +194,27 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     T& MutableMultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is)
     {
-	IndexType ii(*MAB::mProtoI);
+	IndexType ii(*MAB::mProtoI,this->data());
 	ii(is);
 	return (*this)[ii];
     }
 
+    template <typename T, class... SRanges>
+    typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::begin()
+    {
+	IndexType i(*MAB::mProtoI,this->data(),true);
+	i = 0;
+	return i.setData(data());
+    }
+    
+    template <typename T, class... SRanges>
+    typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::end()
+    {
+	IndexType i(*MAB::mProtoI,this->data(),true);
+	i = i.max();
+	return i.setData(data());
+    }
+
     
     template <typename T, class... SRanges>
     bool MutableMultiArrayBase<T,SRanges...>::isConst() const
@@ -238,7 +231,7 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     OperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<IndexType>& ind)
+    MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind)
     {
 	return OperationRoot<T,SRanges...>(data(), *ind);
     }
@@ -252,7 +245,7 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     ConstOperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<IndexType>& ind) const
+    MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
     {
 	return ConstOperationRoot<T,SRanges...>(data(), *ind);
     }
diff --git a/src/include/multi_array_base.h b/src/include/multi_array_base.h
index 2e27abe..1269cbc 100644
--- a/src/include/multi_array_base.h
+++ b/src/include/multi_array_base.h
@@ -57,12 +57,13 @@ namespace MultiArrayTools
 
 	typedef T value_type;
 	typedef ContainerRange<SRanges...> CRange;
-	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> CIndexType;
+	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
 
     protected:
 	bool mInit = false;
 	std::shared_ptr<CRange> mRange;
-	std::shared_ptr<IndexType> mProtoI;
+	std::shared_ptr<CIndexType> mProtoI;
 
     public:
 
@@ -82,7 +83,7 @@ namespace MultiArrayTools
 	const T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
         const T& operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const;
         
-	virtual const T& operator[](const IndexType& i) const = 0;
+	virtual const T& operator[](const CIndexType& i) const = 0;
 	virtual const T& at(const typename CRange::IndexType::MetaType& meta) const = 0;
 
 	virtual const T* data() const = 0;
@@ -90,12 +91,11 @@ namespace MultiArrayTools
 	virtual size_t size() const; 
 	virtual bool isSlice() const = 0;
 
-	virtual IndexType begin() const;
-	virtual IndexType end() const;
+	virtual CIndexType begin() const;
+	virtual CIndexType end() const;
+	virtual CIndexType cbegin() const;
+	virtual CIndexType cend() const;
 	
-	virtual IndexType beginIndex() const;
-	virtual IndexType endIndex() const;
-
 	virtual const std::shared_ptr<CRange>& range() const;
 
 	virtual bool isConst() const;
@@ -103,7 +103,7 @@ namespace MultiArrayTools
 	virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const = 0;
 
 	virtual ConstOperationRoot<T,SRanges...>
-	op(const std::shared_ptr<IndexType>& ind) const;
+	op(const std::shared_ptr<CIndexType>& ind) const;
 	
 	virtual ConstOperationRoot<T,SRanges...>
 	operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const;
@@ -127,13 +127,16 @@ namespace MultiArrayTools
 
 	typedef ContainerRange<SRanges...> CRange;
 	typedef MultiArrayBase<T,SRanges...> MAB;
-	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
+	typedef ConstContainerIndex<T,typename SRanges::IndexType...> CIndexType;
 	
 	using MultiArrayBase<T,SRanges...>::operator[];
 	using MultiArrayBase<T,SRanges...>::at;
 	using MultiArrayBase<T,SRanges...>::data;
 	using MultiArrayBase<T,SRanges...>::begin;
 	using MultiArrayBase<T,SRanges...>::end;
+	using MultiArrayBase<T,SRanges...>::cbegin;
+	using MultiArrayBase<T,SRanges...>::cend;
 	
 	DEFAULT_MEMBERS(MutableMultiArrayBase);
 	MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges);
@@ -143,26 +146,24 @@ namespace MultiArrayTools
 	T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
         T& operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is);
         
-	virtual T& operator[](const IndexType& i) = 0;
+	virtual T& operator[](const CIndexType& i) = 0;
 	virtual T& at(const typename CRange::IndexType::MetaType& meta) = 0;
 	
 	virtual T* data() = 0;
 	
-	//virtual IndexType begin();
-	//virtual IndexType end();
+	virtual IndexType begin();
+	virtual IndexType end();
 
 	virtual bool isConst() const override;
 
-	//virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymousMove() = 0;
-	
 	virtual ConstOperationRoot<T,SRanges...>
-	op(const std::shared_ptr<IndexType>& ind) const override;
+	op(const std::shared_ptr<CIndexType>& ind) const override;
 
 	virtual ConstOperationRoot<T,SRanges...>
 	operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const override;
 
 	virtual OperationRoot<T,SRanges...>
-	op(const std::shared_ptr<IndexType>& ind);
+	op(const std::shared_ptr<CIndexType>& ind);
 
 	virtual OperationRoot<T,SRanges...> operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds);
 
diff --git a/src/tests/ma_unit_test.cc b/src/tests/ma_unit_test.cc
index 20847ee..67f7b06 100644
--- a/src/tests/ma_unit_test.cc
+++ b/src/tests/ma_unit_test.cc
@@ -103,7 +103,7 @@ namespace {
 	EXPECT_EQ( ma.isConst(), false);
 	EXPECT_EQ( ma.isSlice(), false);	
 	
-	auto i = ma.beginIndex();
+	auto i = ma.cbegin();
 	EXPECT_EQ( ma[ i.at('x') ], 3.141);
 	EXPECT_EQ( ma[ i.at('y') ], 2.718);
 	EXPECT_EQ( ma[ i.at('l') ], 1.618);
@@ -143,11 +143,11 @@ namespace {
 	std::shared_ptr<SRange> sr2 = std::dynamic_pointer_cast<SRange>( rfbptr->create() );
 	
 	MultiArray<double,MATest_1Dim::SRange> ma(srptr, vv);
-	auto i = ma.beginIndex();
+	auto i = ma.cbegin();
 	EXPECT_EQ( ma[ i.at('x') ], 3.141);
 
 	auto ma2 = ma.format( sr2 );
-	auto j = ma2.beginIndex();
+	auto j = ma2.cbegin();
 	
 	EXPECT_EQ( ma[ j.at('a') ], 3.141);
 	EXPECT_EQ( ma[ j.at('c') ], 2.718);
@@ -162,7 +162,7 @@ namespace {
 	EXPECT_EQ( ma.size(), 24u );
 	EXPECT_EQ( ma.range()->dim(), 2u );
 
-	auto i = ma.beginIndex();
+	auto i = ma.cbegin();
 	EXPECT_EQ( ma[ i.at( mkt( mkt('x', 'a'), '1' ) ) ], 2.917);
 	EXPECT_EQ( ma[ i.at( mkt( mkt('x', 'a'), '2' ) ) ], 9.436);
 
@@ -178,7 +178,7 @@ namespace {
 	MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
 
 	auto ma2 = ma.format( sr4ptr );
-	auto i = ma2.beginIndex();
+	auto i = ma2.cbegin();
 	EXPECT_EQ( ma2.at('A') , 2.917 );
 	EXPECT_EQ( ma2[ i.at('G') ], 4.892 );
 	EXPECT_EQ( ma2.at('J') , 4.790 );

From c26fb133ae8188eda72be0d474a435a20a7f52dc Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Tue, 8 Jun 2021 16:41:28 +0200
Subject: [PATCH 37/56] replace/remove static for macros

---
 src/include/helper_tools.cc.h          |  5 ++--
 src/include/multi_array.cc.h           | 12 ++++----
 src/include/multi_array_operation.cc.h | 30 ++++++-------------
 src/include/multi_array_operation.h    | 40 ++------------------------
 src/include/slice.cc.h                 | 27 +++++++++++------
 src/include/slice.h                    | 18 ++++++++----
 src/include/statics/static_for.h       | 11 -------
 src/include/type_operations.h          |  5 +++-
 8 files changed, 54 insertions(+), 94 deletions(-)

diff --git a/src/include/helper_tools.cc.h b/src/include/helper_tools.cc.h
index 3e9b4b7..8822929 100644
--- a/src/include/helper_tools.cc.h
+++ b/src/include/helper_tools.cc.h
@@ -6,7 +6,7 @@ namespace MultiArrayTools
     template <typename... T>
     std::ostream& operator<<(std::ostream& out, const std::tuple<T...>& tp)
     {
-	MA_SFOR(i,0,sizeof...(T)-1,i+1, out << std::get<i>(tp) << ", ";);
+	sfor_pn<0,sizeof...(T)-1>( [&](auto i){ out << std::get<i>(tp) << ", "; return 0; } );
 	out << std::get<sizeof...(T)-1>(tp);
 	return out;
     }
@@ -22,8 +22,7 @@ namespace MultiArrayTools
     auto getIndex()
 	-> std::shared_ptr<typename RangeType::IndexType>
     {
-	static_assert( RangeType::defaultable,
-		       /*typeid(typename RangeType).name() + */" is not defaultable" );
+	static_assert( RangeType::defaultable, "Range not defaultable" );
 	static auto f = RangeType::factory();
 	static auto r = std::dynamic_pointer_cast<RangeType>( f.create() );
 	return std::make_shared<typename RangeType::IndexType>(r);
diff --git a/src/include/multi_array.cc.h b/src/include/multi_array.cc.h
index 592255d..1601be3 100644
--- a/src/include/multi_array.cc.h
+++ b/src/include/multi_array.cc.h
@@ -206,9 +206,9 @@ namespace MultiArrayTools
 	    (*this) = in;
 	}
 	else {
-	    MA_SCFOR2(i,0,sizeof...(SRanges),i+1,
-		      std::get<i>(MAB::mRange->space()).get() == std::get<i>(in.mRange->space()).get(),
-		      operator&&);
+	    sfor_p<0,sizeof...(SRanges),0>
+		( [&](auto i) { return std::get<i>(MAB::mRange->space()).get() == std::get<i>(in.mRange->space()).get(); },
+		  [&](auto a, auto b) { return a and b; });
             for(size_t i = 0; i != mCont.size(); ++i){
                 mCont[i] += in.mCont[i];
             }
@@ -223,9 +223,9 @@ namespace MultiArrayTools
 	    (*this) = in;
 	}
 	else {
-	    MA_SCFOR2(i,0,sizeof...(SRanges),i+1,
-		      std::get<i>(MAB::mRange->space()).get() == std::get<i>(in.mRange->space()).get(),
-		      operator&&);
+	    sfor_p<0,sizeof...(SRanges),0>
+		( [&](auto i) { return std::get<i>(MAB::mRange->space()).get() == std::get<i>(in.mRange->space()).get(); },
+		  [&](auto a, auto b) { return a and b; });
             for(size_t i = 0; i != mCont.size(); ++i){
                 mCont[i] -= in.mCont[i];
             }
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index dbee69f..7639247 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -216,7 +216,6 @@ namespace MultiArrayTools
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
     inline DExt AssignmentExpr<T,IOp,Target,OpClass,OIA>::dExtension() const
     {
-        CHECK;
         return nullptr; //???!!!
     }
 
@@ -243,7 +242,10 @@ namespace MultiArrayTools
     template <class Expr>
     auto MOp<T,Ops...>::loop(Expr exp) const
     {
-	return MA_SCRAFOR(i,sizeof...(Ops),0,i-1,std::get<i>(mOps.mOps),loop,exp);
+	return sfor_m<sizeof...(Ops),0>
+	    ( [&](auto i){ return std::get<i>(mOps.mOps); },
+	      [&](auto f, auto next) { return f.loop(next); },
+	      exp );
     }
 
     template <typename T, class... Ops>
@@ -331,7 +333,6 @@ namespace MultiArrayTools
     {
 	mIndex(indices...);
         mDataPtr = mOrigDataPtr + mIndex.pos();
-	//mOff = mIndex.pos();
     }
 
     template <typename T, class... Ranges>
@@ -342,21 +343,19 @@ namespace MultiArrayTools
 	mIndex( ind )
     {
         mDataPtr = mOrigDataPtr + mIndex.pos();
-	//mOff = mIndex.pos();
     }
 
     template <typename T, class... Ranges>
     template <class ET>
     inline const T& ConstOperationRoot<T,Ranges...>::get(ET pos) const
     {
-	return mDataPtr[pos.val()/*+mOff*/];
+	return mDataPtr[pos.val()];
     }
 
     template <typename T, class... Ranges>
     template <typename V, class ET>
     inline const V& ConstOperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	//VCHECK(pos.val());
 	return *(reinterpret_cast<const V*>(mDataPtr+pos.val()));
     }
 
@@ -364,8 +363,6 @@ namespace MultiArrayTools
     template <class ET>
     inline ConstOperationRoot<T,Ranges...>& ConstOperationRoot<T,Ranges...>::set(ET pos)
     {
-	//mIndex = pos.val();
-	//mDataPtr = mOrigDataPtr + mIndex.pos();
         mDataPtr = mOrigDataPtr + pos.val();
 	return *this;
     }
@@ -373,8 +370,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     const T* ConstOperationRoot<T,Ranges...>::data() const
     {
-        //auto i = mIndex;
-	//return mOrigDataPtr/* + i().pos()*/;
         return mDataPtr;
     }
     
@@ -452,9 +447,6 @@ namespace MultiArrayTools
     inline typename MetaOperationRoot<Range>::value_type
     MetaOperationRoot<Range>::get(ET pos) const
     {
-	//VCHECK(pos.val());
-	//VCHECK(mDataPtr);
-	//VCHECK(mDataPtr[pos.val()])
 	return (mWorkIndex = pos.val()).meta();
     }
 
@@ -471,7 +463,6 @@ namespace MultiArrayTools
     template <class ET>
     inline MetaOperationRoot<Range>& MetaOperationRoot<Range>::set(ET pos)
     {
-	//(*mIndex) = pos.val();
 	return *this;
     }
 
@@ -646,7 +637,6 @@ namespace MultiArrayTools
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator+=(const OpClass& in)
     {
 	VExec<OpClass::VABLE>::template exec<xxxplus>(*this,in);
-        //plus(in)();
         return *this;
     }
 
@@ -673,7 +663,6 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	//VCHECK(pos.val());
 	return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
 
@@ -681,8 +670,6 @@ namespace MultiArrayTools
     template <class ET>
     inline OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::set(ET pos)
     {
-	//mIndex = pos.val();
-	//mDataPtr = mOrigDataPtr + mIndex.pos();
         mDataPtr = mOrigDataPtr + pos.val();
 	return *this;
     }
@@ -703,8 +690,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     T* OperationRoot<T,Ranges...>::data() const
     {
-        //auto i = mIndex;
-	//return mOrigDataPtr/* + i().pos()*/;
         return mDataPtr;
     }
 
@@ -1063,7 +1048,10 @@ namespace MultiArrayTools
     template <class Expr>
     auto Operation<T,OpFunction,Ops...>::loop(Expr exp) const
     {
-	return MA_SCRAFOR(i,sizeof...(Ops),0,i-1,std::get<i>(mOps.mOps),loop,exp);
+	return sfor_m<sizeof...(Ops),0>
+	    ( [&](auto i){ return std::get<i>(mOps.mOps); },
+	      [&](auto f, auto next) { return f.loop(next); },
+	      exp );
     }
 
     
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index f3e32b2..18e67e4 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -310,7 +310,9 @@ namespace MultiArrayTools
     template <class... Ops>
     auto OperationTuple<Ops...>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return MA_SCFOR(i,0,sizeof...(Ops),i+1,std::get<i>(mOps).rootSteps(iPtrNum),extend);
+	return sfor_p<0,sizeof...(Ops)>
+	    ( [&](auto i){ return std::get<i>(mOps).rootSteps(iPtrNum); },
+	      [&](auto f, auto next) { return f.extend(next); } );
     }
     
     template <typename T, class... Ops>
@@ -778,42 +780,6 @@ namespace MultiArrayTools
 	T const** data() const { assert(0); return nullptr; }
     };
 
-    /*
-    template <typename T>
-    struct TFold
-    {
-	TFold() = default;
-	TFold(const TFold& in) = default;
-	TFold& operator=(const TFold& in) = default;
-	TFold(TFold&& in) = default;
-	TFold& operator=(TFold&& in) = default;
-	explicit TFold(const T v) : val(v) {}
-	
-	T val;
-	inline T& operator*() { return val; }
-	inline const T& operator*() const { return val; }
-    };
-
-    template <typename T1, typename T2>
-    inline std::tuple<TFold<T1>,TFold<T2>> operator,(const TFold<T1>& a1, const TFold<T2>& a2)
-    {
-	return std::make_tuple(a1,a2);
-    }
-
-    template <typename T1, typename T2...>
-    inline std::tuple<TFold<T1>,TFold<T2>> operator,(const TFold<T1>& a1,
-						     const std::tuple<TFold<T2>...>& a2)
-    {
-	return std::tuple_cat(std::make_tuple(a1),a2);
-    }
-
-    template <typename T2, typename T1...>
-    inline std::tuple<TFold<T1>,TFold<T2>> operator,(const std::tuple<TFold<T1>...>& a1,
-						     const TFold<T2>& a2)
-    {
-	return std::tuple_cat(a1,std::make_tuple(a2));
-    }
-    */
     template <typename T, class OpFunction, class... Ops>
     class Operation : public OperationTemplate<T,Operation<T,OpFunction,Ops...> >
     {
diff --git a/src/include/slice.cc.h b/src/include/slice.cc.h
index 0505805..54235c3 100644
--- a/src/include/slice.cc.h
+++ b/src/include/slice.cc.h
@@ -243,9 +243,12 @@ namespace MultiArrayTools
     SliceDef<T,SRanges...>& SliceDef<T,SRanges...>::operator=(const OperationRoot<T,ORanges...>& op)
     {
 	std::array<size_t,sizeof...(SRanges)+1> blocks;
-	MA_SFOR(i,0,sizeof...(SRanges),i+1,
-		std::get<i+1>(blocks) = op.rootSteps(reinterpret_cast<std::intptr_t>
-						   ( mIndex.template getPtr<i>().get())).val(););
+	sfor_pn<0,sizeof...(SRanges)>
+	    ( [&](auto i) {
+		std::get<i+1>(blocks) =
+		    op.rootSteps(reinterpret_cast<std::intptr_t>
+				 ( mIndex.template getPtr<i>().get())).val();
+		return 0; } );
 	mSl.format(blocks);
 	mSl.mData = op.data();
 	return *this;
@@ -265,9 +268,12 @@ namespace MultiArrayTools
     ConstSliceDef<T,SRanges...>& ConstSliceDef<T,SRanges...>::operator=(const ConstOperationRoot<T,ORanges...>& op)
     {
 	std::array<size_t,sizeof...(SRanges)+1> blocks;
-	MA_SFOR(i,0,sizeof...(SRanges),i+1,
-		std::get<i+1>(blocks) = op.rootSteps(reinterpret_cast<std::intptr_t>
-						   ( mIndex.template getPtr<i>().get())).val(););
+	sfor_pn<0,sizeof...(SRanges)>
+	    ( [&](auto i) {
+		std::get<i+1>(blocks) =
+		    op.rootSteps(reinterpret_cast<std::intptr_t>
+				 ( mIndex.template getPtr<i>().get())).val();
+		return 0; } );
 	mSl.format(blocks);
 	mSl.mData = op.data();
 	return *this;
@@ -278,9 +284,12 @@ namespace MultiArrayTools
     ConstSliceDef<T,SRanges...>& ConstSliceDef<T,SRanges...>::operator=(const OperationRoot<T,ORanges...>& op)
     {
 	std::array<size_t,sizeof...(SRanges)+1> blocks;
-	MA_SFOR(i,0,sizeof...(SRanges),i+1,
-		std::get<i+1>(blocks) = op.rootSteps(reinterpret_cast<std::intptr_t>
-						   ( mIndex.template getPtr<i>().get())).val(););
+	sfor_pn<0,sizeof...(SRanges)>
+	    ( [&](auto i) {
+		std::get<i+1>(blocks) =
+		    op.rootSteps(reinterpret_cast<std::intptr_t>
+				 ( mIndex.template getPtr<i>().get())).val();
+		return 0; } );
 	mSl.format(blocks);
 	mSl.mData = op.data();
 	return *this;
diff --git a/src/include/slice.h b/src/include/slice.h
index 70c1af3..ab7d196 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -112,9 +112,12 @@ namespace MultiArrayTools
 	{
 	    Slice<T,SRanges...> out(ind->range()->space(), &*ind);
 	    std::array<size_t,sizeof...(SRanges)+1> ff;
-	    MA_SFOR(i,0,sizeof...(SRanges),i+1,
-		std::get<i+1>(ff) = op.rootSteps(reinterpret_cast<std::intptr_t>
-						 ( ind.template getPtr<i>().get())).val(););
+	    sfor_pn<0,sizeof...(SRanges)>
+		( [&](auto i) {
+		    std::get<i+1>(ff) =
+			op.rootSteps(reinterpret_cast<std::intptr_t>
+				     ( ind.template getPtr<i>().get())).val();
+		    return 0; } );
 	    out.format(ff);
 	    return out;
 	}
@@ -145,9 +148,12 @@ namespace MultiArrayTools
 	{
 	    ConstSlice<T,SRanges...> out(ind->range()->space(), &*ind);
 	    std::array<size_t,sizeof...(SRanges)+1> ff;
-	    MA_SFOR(i,0,sizeof...(SRanges),i+1,
-		std::get<i+1>(ff) = op.rootSteps(reinterpret_cast<std::intptr_t>
-						 ( ind.template getPtr<i>().get())).val(););
+	    sfor_pn<0,sizeof...(SRanges)>
+		( [&](auto i) {
+		    std::get<i+1>(ff) =
+			op.rootSteps(reinterpret_cast<std::intptr_t>
+				     ( ind.template getPtr<i>().get())).val();
+		    return 0; } );
 	    out.format(ff);
 	    return out;
 	}
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index 77d393a..5c43d27 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -169,15 +169,4 @@ namespace MultiArrayTools
 
 }
 
-#define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
-#define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
-#define MA_SCFOR2(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto a, auto b) { return conc(a,b); })
-#define MA_SCFOR3(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, conc)
-#define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
-#define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
-#define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
-#define MA_CFOR(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
-
-#define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
-
 #endif
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index 3e13521..be955d1 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -33,7 +33,10 @@ namespace MultiArrayTools
 	inline auto apply(const MultiArray<T,Ranges...>& ma)
 	    -> OperationRoot<T,Ranges...>
 	{
-	    return MA_CFOR(i,0,sizeof...(Ranges),i+1,return std::get<i>(ituple);,ma);
+	    return unpack<0,sizeof...(Ranges),0>
+		( [&](auto i) constexpr { return i+1; },
+		  [&](auto i){ return std::get<i>(ituple); },
+		  [&](auto... args) { return ma(args...); });
 	}
 
     private:

From f1b44cfd5c9e99a8ff666cd2efedb5bf4401c77c Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Tue, 8 Jun 2021 17:53:51 +0200
Subject: [PATCH 38/56] sfor: return cond

---
 src/include/statics/static_for.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index 5c43d27..b4a76e0 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -7,7 +7,7 @@
 namespace MultiArrayTools
 {
     template <size_t BEG, size_t END, int OFF, typename Incr, typename F>
-    inline void sfor(Incr incr, F f)
+    inline auto sfor(Incr incr, F f)
     {
 	constexpr auto idx = std::integral_constant<size_t, BEG>{};
 	constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
@@ -18,6 +18,7 @@ namespace MultiArrayTools
 		sfor<incr(idx),END,OFF>(incr,f);
 	    }
 	}
+	return cond;
     }
 
     template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Cond>

From 49f2c41a9585b889d411e901e3010e5df051a478 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 9 Jun 2021 17:25:02 +0200
Subject: [PATCH 39/56] remove dead code + simplify StaticFunctionBase (less
 template args)

---
 src/include/arith.cc.h         |  35 ++++++
 src/include/arith.h            | 206 +++++++++------------------------
 src/include/operation_helper.h |  46 --------
 3 files changed, 92 insertions(+), 195 deletions(-)
 create mode 100644 src/include/arith.cc.h
 delete mode 100644 src/include/operation_helper.h

diff --git a/src/include/arith.cc.h b/src/include/arith.cc.h
new file mode 100644
index 0000000..28dae5d
--- /dev/null
+++ b/src/include/arith.cc.h
@@ -0,0 +1,35 @@
+
+#include "arith.h"
+
+namespace MultiArrayTools
+{
+
+    template <class F>
+    template <class... Ops>
+    auto StaticFunctionBase<F>::mk(const Ops&... ops)
+    {
+        return Operation<typename F::value_type,F,Ops...>(ops...);
+    }
+
+    template <class F>
+    template <size_t N, class Tuple, typename... As>
+    inline auto StaticFunctionBase<F>::xapply(const Tuple& tp, As... as)
+    {
+        if constexpr(N > 0){
+            return xapply<N-1>(tp, std::get<N>(tp), as...);
+        }
+        else {
+            return F::apply(std::get<0>(tp), as...);
+        }
+    }
+
+    template <class F>
+    template <typename... As>
+    inline auto StaticFunctionBase<F>::apply(const std::tuple<As...>& arg)
+    {
+        return xapply<sizeof...(As)-1>(arg);
+        //return ArgPack<sizeof...(As)-1>::template mk<F,std::tuple<As...> >(arg);
+    }
+
+    
+}
diff --git a/src/include/arith.h b/src/include/arith.h
index e9339d8..6423911 100644
--- a/src/include/arith.h
+++ b/src/include/arith.h
@@ -7,70 +7,33 @@
 namespace MultiArrayTools
 {
 
-    template <size_t N>
-    struct ArgPack
-    {
-	template <class F, class Tuple, typename... As>
-	static inline auto mk(const Tuple& tp, As... as)
-	    -> decltype(ArgPack<N-1>::template mk<F,Tuple,decltype(std::get<N>(tp)),As...>(tp, std::get<N>(tp), as...))
-	{
-	    return ArgPack<N-1>::template mk<F,Tuple,decltype(std::get<N>(tp)),As...>(tp, std::get<N>(tp), as...);
-	}
-        
-	template <class F, class Tuple, typename... As>
-	static inline auto mkd(const F& ff, const Tuple& tp, As... as)
-	    -> decltype(ArgPack<N-1>::template mkd<F,Tuple,decltype(std::get<N>(tp)),As...>(ff, tp, std::get<N>(tp), as...))
-    	{
-	    return ArgPack<N-1>::template mkd<F,Tuple,decltype(std::get<N>(tp)),As...>(ff, tp, std::get<N>(tp), as...);
-	}
-    };
-
-    template <>
-    struct ArgPack<0>
-    {
-	template <class F, class Tuple, typename... As>
-	static inline auto mk(const Tuple& tp, As... as)
-	    -> decltype(F::apply(std::get<0>(tp), as...))
-	{
-	    return F::apply(std::get<0>(tp), as...);
-	}
-
-    	template <class F, class Tuple, typename... As>
-	static inline auto mkd(const F& ff, const Tuple& tp, As... as)
-	    -> decltype(ff(std::get<0>(tp), as...))
-	{
-	    return ff(std::get<0>(tp), as...);
-	}
-    };
-
-    template <typename T, class F, typename... As>
+    //template <typename T, class F, typename... As>
+    template <class F>
     struct StaticFunctionBase
     {
 	static constexpr bool FISSTATIC = true;
-	typedef T value_type;
 	typedef F function;
+	//typedef typename F::value_type value_type;
 
 	template <class... Ops>
-	static auto mk(const Ops&... ops)
-	    -> Operation<T,F,Ops...>
-	{
-	    return Operation<T,F,Ops...>(ops...);
-	}
+	static auto mk(const Ops&... ops);
 
-	static inline T apply(const std::tuple<As...>& arg)
-	{
-	    return ArgPack<sizeof...(As)-1>::template mk<F,std::tuple<As...> >(arg);
-	}
+        template <size_t N, class Tuple, typename... As>
+        static inline auto xapply(const Tuple& tp, As... as);
+
+        template <typename... As>
+	static inline auto apply(const std::tuple<As...>& arg);
     };
 
 
     // OPERATIONS (STATIC)
     template <typename T>
-    struct identity : public StaticFunctionBase<T, identity<T>, T>
+    struct identity : public StaticFunctionBase<identity<T>>
     {
 	//static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<T, identity<T>, T>::apply;
-	
+	using StaticFunctionBase<identity<T>>::apply;
+        typedef T value_type;
+        
 	static inline T apply(T a)
 	{
 	    return a;
@@ -95,12 +58,13 @@ namespace MultiArrayTools
     using dividesv = decltype(std::declval<T>()/std::declval<U>());
 
     template <typename T, typename U>
-    struct plusx : public StaticFunctionBase<plusv<T,U>, plusx<T,U>, T, U>
+    struct plusx : public StaticFunctionBase<plusx<T,U>>
     {
 	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<plusv<T,U>, plusx<T,U>, T, U>::apply;
-	
-	static inline plusv<T,U> apply(T a1, U a2)
+	using StaticFunctionBase<plusx<T,U>>::apply;
+        typedef plusv<T,U> value_type;
+        
+	static inline value_type apply(T a1, U a2)
 	{
 	    return a1 + a2;
 	}
@@ -112,36 +76,39 @@ namespace MultiArrayTools
     };
 
     template <typename T, typename U>
-    struct minusx : public StaticFunctionBase<minusv<T,U>, minusx<T,U>, T, U>
+    struct minusx : public StaticFunctionBase<minusx<T,U>>
     {
 	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<minusv<T,U>, minusx<T,U>, T, U>::apply;
+	using StaticFunctionBase<minusx<T,U>>::apply;
+        typedef minusv<T,U> value_type;
 	
-	static inline plusv<T,U> apply(T a1, U a2)
+	static inline value_type apply(T a1, U a2)
 	{
 	    return a1 - a2;
 	}
     };
 
     template <typename T, typename U>
-    struct multipliesx : public StaticFunctionBase<multipliesv<T,U>, multipliesx<T,U>, T, U>
+    struct multipliesx : public StaticFunctionBase<multipliesx<T,U>>
     {
 	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<multipliesv<T,U>, multipliesx<T,U>, T, U>::apply;
+	using StaticFunctionBase<multipliesx<T,U>>::apply;
+        typedef multipliesv<T,U> value_type;
 	
-	static inline multipliesv<T,U> apply(T a1, U a2)
+	static inline value_type apply(T a1, U a2)
 	{
 	    return a1 * a2;
 	}
     };
 
     template <typename T, typename U>
-    struct dividesx : public StaticFunctionBase<dividesv<T,U>, dividesx<T,U>, T, U>
+    struct dividesx : public StaticFunctionBase<dividesx<T,U>>
     {
 	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<dividesv<T,U>, dividesx<T,U>, T, U>::apply;
+	using StaticFunctionBase<dividesx<T,U>>::apply;
+        typedef dividesv<T,U> value_type;
 	
-	static inline dividesv<T,U> apply(T a1, U a2)
+	static inline value_type apply(T a1, U a2)
 	{
 	    return a1 / a2;
 	}
@@ -149,11 +116,12 @@ namespace MultiArrayTools
     };
 
     template <typename T>
-    struct negate : public StaticFunctionBase<T, negate<T>, T>
+    struct negate : public StaticFunctionBase<negate<T>>
     {
 	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<T, negate<T>, T>::apply;
-	
+	using StaticFunctionBase<negate<T>>::apply;
+        typedef T value_type;
+        
 	static inline T apply(T a)
 	{
 	    return -a;
@@ -173,60 +141,6 @@ namespace MultiArrayTools
     template <typename T>
     using divides = dividesx<T,T>;
 
-    /*
-    template <typename T>
-    struct plus : public StaticFunctionBase<T, plus<T>, T, T>
-    {
-	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<T, plus<T>, T, T>::apply;
-	
-	static inline T apply(T a1, T a2)
-	{
-	    return a1 + a2;
-	}
-
-    	static inline T& selfApply(T& a1, const T& a2)
-	{
-	    return a1 += a2;
-	}
-    };
-
-    template <typename T>
-    struct minus : public StaticFunctionBase<T, minus<T>, T, T>
-    {
-	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<T, minus<T>, T, T>::apply;
-	
-	static inline T apply(T a1, T a2)
-	{
-	    return a1 - a2;
-	}
-    };
-
-    template <typename T>
-    struct multiplies : public StaticFunctionBase<T, multiplies<T>, T, T>
-    {
-	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<T, multiplies<T>, T, T>::apply;
-	
-	static inline T apply(T a1, T a2)
-	{
-	    return a1 * a2;
-	}
-    };
-
-    template <typename T>
-    struct divides : public StaticFunctionBase<T, divides<T>, T, T>
-    {
-	static constexpr bool FISSTATIC = true;
-	using StaticFunctionBase<T, divides<T>, T, T>::apply;
-	
-	static inline T apply(T a1, T a2)
-	{
-	    return a1 / a2;
-	}
-    };
-    */
     //  OPERATIONS (STATIC)
     template <typename R, typename... Args>
     class function
@@ -247,16 +161,28 @@ namespace MultiArrayTools
             return mF(args...);
         }
 
+        template <size_t N, class Tuple, typename... As>
+        static inline auto xapply(const std::function<R(Args...)>& ff, const Tuple& tp, As... as)
+        {
+            if constexpr(N > 0){
+                return xapply<N-1>(ff, tp, std::get<N>(tp), as...);
+            }
+            else {
+                return ff(std::get<0>(tp), as...);
+            }
+        }
+
         inline R operator()(const std::tuple<Args...>& args)
         {
-            return ArgPack<sizeof...(Args)-1>::template mkd<std::function<R(Args...)>,std::tuple<Args...>>>(mF, args);
+            return xapply<sizeof...(Args)-1>(mF, args);
         }
 };
     
 #include <cmath>
 #define regFunc1(fff) template <typename T>\
-    struct x_##fff : public StaticFunctionBase<T, x_##fff<T>, T> {\
+    struct x_##fff : public StaticFunctionBase<x_##fff<T>> {\
     static constexpr bool FISSTATIC = true;\
+    typedef T value_type; \
     static inline T apply(T a){\
 	return fff(a); } };
 
@@ -271,35 +197,17 @@ namespace MultiArrayTools
 	template <typename T>
 	static inline T apply(T a)
 	{
-	    return a * x_ipow<N-1>::apply(a);
+            if constexpr(N > 0){
+                return a * x_ipow<N-1>::apply(a);
+            }
+            else {
+                return a;
+            }
 	}
     };
 
-    template <>
-    struct x_ipow<0>
-    {
-	static constexpr bool FISSTATIC = true;
-
-	template <typename T>
-	static inline T apply(T a)
-	{
-	    return a;
-	}
-    };
-	
-    /*
-    template <typename T, class Func>
-    struct dynamic_function
-    {
-	static constexpr bool FISSTATIC = false;
-	
-	template <typename... Us>
-	inline T apply(Us... args)
-	{
-	    return f(args...);
-	}
-    };
-    */
 } // end namespace MultiArrayHelper
-    
+
+#include "arith.cc.h"
+
 #endif
diff --git a/src/include/operation_helper.h b/src/include/operation_helper.h
deleted file mode 100644
index 4b4b002..0000000
--- a/src/include/operation_helper.h
+++ /dev/null
@@ -1,46 +0,0 @@
-
-#ifndef __operation_helper_h__
-#define __operation_helper_h__
-
-#include "multi_array_operation.h"
-
-namespace MultiArrayTools
-{
-
-    template <class BaseArray, class... Ranges>
-    class PseudoArray
-    {
-	size_t mThreadNum;
-	Slice<> mSl;
-	mutable ConstOperationRoot<T,Range> mOp;
-	
-    public:
-
-	template <class ET>
-	const SrcHolder<ConstOperationRoot<T,Range>> operator[](ET pos) const;
-    };
-    
-    template <class Operation>
-    class SrcHolder
-    {
-
-	TempHolder operator+(SrcHolder in) const;
-	// aso
-    };
-
-    template <class Operation>
-    class TempHolder
-    {
-	TempHolder operator+(SrcHolder in) const;
-	TempHolder operator+(TempHolder in) const;
-    };
-
-    template <class Operation>
-    class TarHolder
-    {
-	TarHolder& operator=(TempHolder in);
-    };
-    
-} // namespace MultiArrayTools
-
-#endif

From 69917422067efa7a1781a13d4048719b4dbe2b2e Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 11 Jun 2021 18:57:00 +0200
Subject: [PATCH 40/56] remove old code

---
 src/include/functional_multi_array.h  | 66 ---------------------------
 src/include/high_level_operation.h    | 20 ++++++--
 src/include/hl_reg_ind.h              | 52 ---------------------
 src/include/ranges/index_wrapper.cc.h |  9 +---
 src/include/ranges/index_wrapper.h    | 10 +---
 5 files changed, 18 insertions(+), 139 deletions(-)
 delete mode 100644 src/include/hl_reg_ind.h

diff --git a/src/include/functional_multi_array.h b/src/include/functional_multi_array.h
index b2a8251..3652e24 100644
--- a/src/include/functional_multi_array.h
+++ b/src/include/functional_multi_array.h
@@ -7,72 +7,6 @@
 
 namespace MultiArrayTools
 {
-
-    template <bool HASMETACONT>
-    struct ToMAObject
-    {
-	template <class Index>
-	static auto mk(const std::shared_ptr<Index>& i)
-	    -> MultiArray<typename Index::MetaType, typename Index::RangeType>
-	{
-            assert(0); // deprecated
-	    vector<typename Index::MetaType> vv(i->range()->size());
-	    for(Index j = (*i); j.pos() != j.max(); ++j){
-		vv[j.pos()] = j.meta();
-	    }	    
-	    return MultiArray<typename Index::MetaType, typename Index::RangeType>( i->range(), vv );
-	}
-    };
-
-    template <>
-    struct ToMAObject<true>
-    {
-	template <class Index>
-	static auto mk(const std::shared_ptr<Index>& i)
-	    -> ConstSlice<typename Index::MetaType, typename Index::RangeType>
-	{
-	    return ConstSlice<typename Index::MetaType, typename Index::RangeType>( i->range(), i->metaPtr() );
-	}
-    };
-
-    template <class Index>
-    auto mkMAObject(const std::shared_ptr<Index>& i)
-	-> std::shared_ptr<decltype(ToMAObject<Index::RangeType::HASMETACONT>::mk(i))>
-    {
-	return std::make_shared<decltype(ToMAObject<Index::RangeType::HASMETACONT>::mk(i))>
-	    (ToMAObject<Index::RangeType::HASMETACONT>::mk(i));
-    }
-
-    template <bool HASMETACONT>
-    struct ToOpObject
-    {
-	template <class Index>
-	static auto mk(const std::shared_ptr<Index>& ind)
-	    -> ConstOperationRoot<typename Index::MetaType,
-				  typename Index::RangeType>
-	{
-	    return ConstOperationRoot<typename Index::MetaType,
-				      typename Index::RangeType>( mkMAObject(ind), ind);
-	}
-    };
-
-    template <>
-    struct ToOpObject<false>
-    {
-        template <class Index>
-	static auto mk(const std::shared_ptr<Index>& ind)
-	    -> MetaOperationRoot<typename Index::RangeType>
-        {
-            return MetaOperationRoot<typename Index::RangeType>( ind );
-        }
-    };
-    
-    template <class Index>
-    auto mkOpObject(const std::shared_ptr<Index>& i)
-	-> decltype(ToOpObject<Index::RangeType::HASMETACONT>::mk(i))
-    {
-	return ToOpObject<Index::RangeType::HASMETACONT>::mk(i);
-    }
     
     template <typename T, class Function, class... SRanges>
     class FunctionalMultiArray : public MultiArrayBase<T,SRanges...>
diff --git a/src/include/high_level_operation.h b/src/include/high_level_operation.h
index fa1ffc1..d3acf1f 100644
--- a/src/include/high_level_operation.h
+++ b/src/include/high_level_operation.h
@@ -54,7 +54,10 @@ namespace MultiArrayTools
 #define reg_ind3(I1,I2,I3) virtual RetT<I1,I2,I3> create   \
         (const std::shared_ptr<I1>& ind1,const std::shared_ptr<I2>& ind2,const std::shared_ptr<I3>& ind3) = 0
 
-#include "hl_reg_ind.h"
+        //#include "hl_reg_ind.h"
+        reg_ind1(ClassicRange::IndexType);
+        reg_ind2(ClassicRange::IndexType,ClassicRange::IndexType);
+        reg_ind3(ClassicRange::IndexType,ClassicRange::IndexType,ClassicRange::IndexType);
 
 #undef reg_ind1
 #undef reg_ind2
@@ -92,7 +95,10 @@ namespace MultiArrayTools
         (const std::shared_ptr<I1>& ind1, const std::shared_ptr<I2>& ind2, const std::shared_ptr<I3>& ind3) \
             override final { return xcreate(ind1,ind2,ind3); }
 
-#include "hl_reg_ind.h"
+        //#include "hl_reg_ind.h"
+        reg_ind1(ClassicRange::IndexType);
+        reg_ind2(ClassicRange::IndexType,ClassicRange::IndexType);
+        reg_ind3(ClassicRange::IndexType,ClassicRange::IndexType,ClassicRange::IndexType);
 
         virtual ROP* get() override final;
 	virtual VOP* vget() override final;
@@ -121,7 +127,10 @@ namespace MultiArrayTools
         
         virtual bool root() const override final;
 
-#include "hl_reg_ind.h"
+        //#include "hl_reg_ind.h"
+        reg_ind1(ClassicRange::IndexType);
+        reg_ind2(ClassicRange::IndexType,ClassicRange::IndexType);
+        reg_ind3(ClassicRange::IndexType,ClassicRange::IndexType,ClassicRange::IndexType);
     
         virtual ROP* get() override final;
 	virtual VOP* vget() override final;
@@ -158,7 +167,10 @@ namespace MultiArrayTools
         virtual ROP* get() override final;
 	virtual VOP* vget() override final;
     
-#include "hl_reg_ind.h"
+        //#include "hl_reg_ind.h"
+        reg_ind1(ClassicRange::IndexType);
+        reg_ind2(ClassicRange::IndexType,ClassicRange::IndexType);
+        reg_ind3(ClassicRange::IndexType,ClassicRange::IndexType,ClassicRange::IndexType);
 
 #undef reg_ind1
 #undef reg_ind2
diff --git a/src/include/hl_reg_ind.h b/src/include/hl_reg_ind.h
deleted file mode 100644
index 144c5e0..0000000
--- a/src/include/hl_reg_ind.h
+++ /dev/null
@@ -1,52 +0,0 @@
-
-#ifndef __hl_reg_ind_h__
-#define __hl_reg_ind_h__
-
-#include "ranges/rheader.h"
-
-namespace MultiArrayTools
-{
-
-    template <class Index>
-    struct RegIndNum
-    {
-        static constexpr size_t VALUE = -1;
-        static constexpr size_t DEPTH = 0;
-    };
-
-    template <>
-    struct RegIndNum<ClassicRange::IndexType>
-    {
-        static constexpr size_t VALUE = 0;
-        static constexpr size_t DEPTH = 3;
-    };
-
-    // to be returned by IndexWrapper
-    struct RegIndInfo
-    {
-        size_t type;
-        size_t depth;
-
-        template <class Index>
-        RegIndInfo& set(const std::shared_ptr<Index>& i)
-        {
-            type = RegIndNum<Index>::VALUE;
-            depth = RegIndNum<Index>::DEPTH;
-	    return *this;
-        }
-    };
-}
-
-#endif
-
-#ifdef reg_ind1
-#ifdef reg_ind2
-#ifdef reg_ind3
-
-reg_ind1(ClassicRange::IndexType);
-reg_ind2(ClassicRange::IndexType,ClassicRange::IndexType);
-reg_ind3(ClassicRange::IndexType,ClassicRange::IndexType,ClassicRange::IndexType);
-
-#endif
-#endif
-#endif
diff --git a/src/include/ranges/index_wrapper.cc.h b/src/include/ranges/index_wrapper.cc.h
index fd23a05..9b734e9 100644
--- a/src/include/ranges/index_wrapper.cc.h
+++ b/src/include/ranges/index_wrapper.cc.h
@@ -153,14 +153,7 @@ namespace MultiArrayTools
     {
         return std::make_shared<IndexWrapper>( std::make_shared<Index>( *mI ) );
     }
-    /*
-    template <class Index>
-    RegIndInfo IndexWrapper<Index>::regN() const
-    {
-	RegIndInfo out;
-	return out.set(mI);
-    }
-    */
+
     template <class Index>
     std::shared_ptr<Index> IndexWrapper<Index>::getIndex() const
     {
diff --git a/src/include/ranges/index_wrapper.h b/src/include/ranges/index_wrapper.h
index 0df33ff..3a58fd6 100644
--- a/src/include/ranges/index_wrapper.h
+++ b/src/include/ranges/index_wrapper.h
@@ -4,7 +4,7 @@
 
 #include "ranges/rbase_def.h"
 #include "xfor/xfor.h"
-#include "hl_reg_ind.h"
+#include "ranges/rheader.h"
 
 namespace MultiArrayTools
 {
@@ -50,13 +50,6 @@ namespace MultiArrayTools
 
         virtual std::shared_ptr<IndexWrapperBase> duplicate() const = 0;
 
-	//virtual RegIndInfo regN() const = 0;
-        //virtual DynamicMetaT meta() const = 0;
-	//virtual const DynamicMetaT* metaPtr() const = 0;
-	//virtual AbstractIW& at(const U& metaPos) = 0;
-	//virtual size_t posAt(const U& metaPos) const = 0;
-
-	//virtual bool isMeta(const U& metaPos) const = 0;
 	inline IndexWrapperBase& at(const std::string smeta)
 	{
 	    // ignore spaces, " and ' (string identifiers)
@@ -150,7 +143,6 @@ namespace MultiArrayTools
         virtual DynamicExpression iforh(size_t step, DynamicExpression ex) const override final;
 
         virtual std::shared_ptr<IndexWrapperBase> duplicate() const override final;
-	//virtual RegIndInfo regN() const override final;
 
 	std::shared_ptr<Index> getIndex() const;
 	virtual std::shared_ptr<ClassicIndex> reduced() const override final;

From 7cd0c3104f81b6cde00abcd2e92cd3084b0681b7 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 24 Jun 2021 21:39:42 +0200
Subject: [PATCH 41/56] separate lib for high level stuff

---
 src/include/hl_multi_array_header.h |  3 +++
 src/include/multi_array_header.cc.h |  2 +-
 src/include/multi_array_header.h    |  2 +-
 src/lib/CMakeLists.txt              | 28 +++++++++++++++++++++++++++-
 src/lib/high_level_operation.cc     |  2 +-
 src/lib/mk_hl_op.sh                 |  6 +++---
 src/tests/CMakeLists.txt            |  4 ++--
 src/tests/op4_unit_test.cc          |  1 +
 8 files changed, 39 insertions(+), 9 deletions(-)
 create mode 100644 src/include/hl_multi_array_header.h

diff --git a/src/include/hl_multi_array_header.h b/src/include/hl_multi_array_header.h
new file mode 100644
index 0000000..e831a63
--- /dev/null
+++ b/src/include/hl_multi_array_header.h
@@ -0,0 +1,3 @@
+#include "high_level_operation.h"
+
+#include "high_level_operation.cc.h"
diff --git a/src/include/multi_array_header.cc.h b/src/include/multi_array_header.cc.h
index 1149d19..70a281d 100644
--- a/src/include/multi_array_header.cc.h
+++ b/src/include/multi_array_header.cc.h
@@ -10,6 +10,6 @@
 #include "multi_array.cc.h"
 #include "slice.cc.h"
 #include "dynamic_operation.cc.h"
-#include "high_level_operation.cc.h"
+//#include "high_level_operation.cc.h"
 //#include "expressions.cc.h"
 
diff --git a/src/include/multi_array_header.h b/src/include/multi_array_header.h
index f8f2903..05aa1a1 100644
--- a/src/include/multi_array_header.h
+++ b/src/include/multi_array_header.h
@@ -13,7 +13,7 @@
 #include "operation_def.h"
 #include "map_range.h"
 #include "dynamic_operation.h"
-#include "high_level_operation.h"
+//#include "high_level_operation.h"
 
 #include "multi_array_header.cc.h"
 
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index b948709..19f96df 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -10,8 +10,12 @@ set(libmultiarray_a_SOURCES
   ${CMAKE_SOURCE_DIR}/src/lib/ranges/type_map.cc
   ${CMAKE_SOURCE_DIR}/src/lib/ranges/multi_range_factory_product_map.cc
   ${CMAKE_SOURCE_DIR}/src/lib/map_range_factory_product_map.cc
+  )
+
+set(libhlmultiarray_a_SOURCES
   ${CMAKE_SOURCE_DIR}/src/lib/high_level_operation.cc
   )
+#message(WARNING ${libhlmultiarray_a_SOURCES})
 
 file(GLOB cc_files "${CMAKE_SOURCE_DIR}/src/lib/ranges/range_types/*.cc")
 foreach(ccfile ${cc_files})
@@ -21,14 +25,18 @@ endforeach(ccfile)
 
 file(GLOB cc_files "${CMAKE_SOURCE_DIR}/src/lib/hl_ops/*.cc")
 foreach(ccfile ${cc_files})
-  set(libmultiarray_a_SOURCES ${libmultiarray_a_SOURCES}
+  set(libhlmultiarray_a_SOURCES ${libhlmultiarray_a_SOURCES}
     ${ccfile})
 endforeach(ccfile)
 
 add_library(multiarray_obj OBJECT
   ${libmultiarray_a_SOURCES}
   )
+add_library(hlmultiarray_obj OBJECT
+  ${libhlmultiarray_a_SOURCES}
+  )
 set_target_properties(multiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(hlmultiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
 add_library(multiarray SHARED
   $<TARGET_OBJECTS:multiarray_obj>
@@ -40,6 +48,16 @@ add_library(multiarray_static
   )
 set_target_properties(multiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
+add_library(hlmultiarray SHARED
+  $<TARGET_OBJECTS:hlmultiarray_obj>
+  )
+set_target_properties(hlmultiarray PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+
+add_library(hlmultiarray_static
+  $<TARGET_OBJECTS:hlmultiarray_obj>
+  )
+set_target_properties(hlmultiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+
 install(TARGETS multiarray
   ARCHIVE DESTINATION ${INSTALL_PATH}/lib
   LIBRARY DESTINATION ${INSTALL_PATH}/lib)
@@ -47,3 +65,11 @@ install(TARGETS multiarray
 install(TARGETS multiarray_static
   ARCHIVE DESTINATION ${INSTALL_PATH}/lib
   LIBRARY DESTINATION ${INSTALL_PATH}/lib)
+
+install(TARGETS hlmultiarray
+  ARCHIVE DESTINATION ${INSTALL_PATH}/lib
+  LIBRARY DESTINATION ${INSTALL_PATH}/lib)
+
+install(TARGETS hlmultiarray_static
+  ARCHIVE DESTINATION ${INSTALL_PATH}/lib
+  LIBRARY DESTINATION ${INSTALL_PATH}/lib)
diff --git a/src/lib/high_level_operation.cc b/src/lib/high_level_operation.cc
index 6f9f706..2cc2938 100644
--- a/src/lib/high_level_operation.cc
+++ b/src/lib/high_level_operation.cc
@@ -1,6 +1,6 @@
 
 #include "multi_array_header.h"
-#include "high_level_operation.h"
+#include "hl_multi_array_header.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/lib/mk_hl_op.sh b/src/lib/mk_hl_op.sh
index f904f85..66514c3 100755
--- a/src/lib/mk_hl_op.sh
+++ b/src/lib/mk_hl_op.sh
@@ -10,7 +10,7 @@ for x in $(cat ../include/extensions/math.h) ; do
     file=hl_ops/${fff}.cc
     test -f ${file} && rm -f ${file}
     echo "#include \"multi_array_header.h\"" >> ${file}
-    echo "#include \"high_level_operation.h\"" >> ${file}
+    echo "#include \"hl_multi_array_header.h\"" >> ${file}
     echo "" >> ${file}
     echo "namespace MultiArrayTools" >> ${file}
     echo "{" >> ${file}
@@ -25,7 +25,7 @@ for fff in plus minus multiplies divides ; do
     file=hl_ops/${fff}.cc
     test -f ${file} && rm -f ${file}
     echo "#include \"multi_array_header.h\"" >> ${file}
-    echo "#include \"high_level_operation.h\"" >> ${file}
+    echo "#include \"hl_multi_array_header.h\"" >> ${file}
     echo "" >> ${file}
     echo "namespace MultiArrayTools" >> ${file}
     echo "{" >> ${file}
@@ -38,7 +38,7 @@ for fff in negate ; do
     file=hl_ops/${fff}.cc
     test -f ${file} && rm -f ${file}
     echo "#include \"multi_array_header.h\"" >> ${file}
-    echo "#include \"high_level_operation.h\"" >> ${file}
+    echo "#include \"hl_multi_array_header.h\"" >> ${file}
     echo "" >> ${file}
     echo "namespace MultiArrayTools" >> ${file}
     echo "{" >> ${file}
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index b272f7f..bad8c59 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -32,8 +32,8 @@ target_link_libraries(op3utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
 add_test(NAME op3utest COMMAND op3utest)
 
 add_executable(op4utest op4_unit_test.cc)
-add_dependencies(op4utest multiarray)
-target_link_libraries(op4utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(op4utest multiarray hlmultiarray)
+target_link_libraries(op4utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray hlmultiarray)
 add_test(NAME op4utest COMMAND op4utest)
 
 add_executable(opptest op_perf_test.cc)
diff --git a/src/tests/op4_unit_test.cc b/src/tests/op4_unit_test.cc
index 2cd67f5..313b79a 100644
--- a/src/tests/op4_unit_test.cc
+++ b/src/tests/op4_unit_test.cc
@@ -1,5 +1,6 @@
 
 #include "test_header.h"
+#include "hl_multi_array_header.h"
 #include <ctime>
 
 namespace

From ffb8e71dbdadff7eeb7090dd6bd0c25d1bfd8f0e Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 25 Jun 2021 17:28:22 +0200
Subject: [PATCH 42/56] multi_array_operation: replace template spec by static
 if

---
 src/include/multi_array_operation.cc.h | 59 +++++++++++---------------
 1 file changed, 25 insertions(+), 34 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 7639247..3e47fcd 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -592,43 +592,34 @@ namespace MultiArrayTools
         return this->template asx<IPlus<T>>(in,i);
     }
 
-    template <bool VABLE = false>
-    struct VExec
+    template <bool VABLE, template <typename> class F, typename TarOp, class OpClass>
+    inline void vexec(TarOp& th, const OpClass& in)
     {
-	template <template <typename> class F, typename TarOp, class OpClass>
-	static inline void exec(TarOp& th, const OpClass& in)
-	{
-	    typedef typename TarOp::value_type T;
-	    IAccess<T,F<T>> tmp;
-	    th.template asx<decltype(tmp)>(in)();
-	}
-    };
-
-    template <>
-    struct VExec<true>
-    {
-	template <template <typename> class F, typename TarOp, class OpClass>
-	static inline void exec(TarOp& th, const OpClass& in)
-	{
-	    CHECK;
-	    typedef typename TarOp::value_type T;
-	    auto x = th.template asx<IVAccess<T,F<T>>>(in);
-	    if(x.rootSteps(x.vI()) == 1){
-	    //if(0){
-		CHECK;
-		x();
-	    }
-	    else {
-		th.template asx<IAccess<T,F<T>>>(in)();
-	    }
-	}
-    };
+        if constexpr(VABLE){
+            CHECK;
+            typedef typename TarOp::value_type T;
+            auto x = th.template asx<IVAccess<T,F<T>>>(in);
+            if(x.rootSteps(x.vI()) == 1){
+                //if(0){
+                CHECK;
+                x();
+            }
+            else {
+                th.template asx<IAccess<T,F<T>>>(in)();
+            }
+        }
+        else {
+            typedef typename TarOp::value_type T;
+            IAccess<T,F<T>> tmp;
+            th.template asx<decltype(tmp)>(in)();
+        }
+    }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-	VExec<OpClass::VABLE>::template exec<identity>(*this,in);
+	vexec<OpClass::VABLE,identity>(*this,in);
         return *this;
     }
 
@@ -636,7 +627,7 @@ namespace MultiArrayTools
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator+=(const OpClass& in)
     {
-	VExec<OpClass::VABLE>::template exec<xxxplus>(*this,in);
+	vexec<OpClass::VABLE,xxxplus>(*this,in);
         return *this;
     }
 
@@ -807,7 +798,7 @@ namespace MultiArrayTools
     template <class OpClass>
     ParallelOperationRoot<T,Ranges...>& ParallelOperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-	VExec<OpClass::VABLE>::template exec<identity>(*this,in);
+	vexec<OpClass::VABLE,identity>(*this,in);
         return *this;
     }
 
@@ -815,7 +806,7 @@ namespace MultiArrayTools
     template <class OpClass>
     ParallelOperationRoot<T,Ranges...>& ParallelOperationRoot<T,Ranges...>::operator+=(const OpClass& in)
     {
-	VExec<OpClass::VABLE>::template exec<xxxplus>(*this,in);
+	vexec<OpClass::VABLE,xxxplus>(*this,in);
         return *this;
     }
 

From d5e02ba9d2ecfaac170610ab0390935a29c4f224 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sat, 26 Jun 2021 00:40:42 +0200
Subject: [PATCH 43/56] remove slicecontraction + start hyperoperation (for
 slicearray)

---
 src/include/multi_array_operation.cc.h | 60 +++-----------------------
 src/include/multi_array_operation.h    | 49 +++++++++++----------
 src/tests/op_unit_test.cc              | 31 -------------
 3 files changed, 29 insertions(+), 111 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 7639247..1b0b974 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -66,15 +66,6 @@ namespace MultiArrayTools
 	return out;
     }
 
-    template <typename T, class OperationClass>
-    template <class... Indices>
-    auto OperationBase<T,OperationClass>::slc(const std::shared_ptr<Indices>&... inds) const
-	-> SliceContraction<T,OperationClass,Indices...>
-    {
-	return SliceContraction<T,OperationClass,Indices...>
-	    (THIS(), inds...);
-    }
-
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::p(const std::shared_ptr<Indices>&... inds) const
@@ -144,6 +135,11 @@ namespace MultiArrayTools
 	return OperationPointer<T,OperationClass>(THIS());
     }
 
+    template <class... Indices>
+    HyperOperation ho(const std::shared_ptr<Indices>& inds...) const
+    {
+	return HyperOperation<T,SubOp,Indices...>()
+    }
     
     /************************
      *   AssignmentExpr     *
@@ -1104,50 +1100,4 @@ namespace MultiArrayTools
 	return mInd->iforh(0,mOp.loop(exp));
     }
 
-    /**************************
-     *   SliceContraction     *
-     **************************/
-
-    template <typename T, class Op, class... Indices>
-    SliceContraction<T,Op,Indices...>::SliceContraction(const Op& op,
-							std::shared_ptr<Indices>... ind) :
-	mOp(op),
-	mCont(std::make_shared<MultiArray<T,typename Indices::RangeType...> >(ind->range()...)),
-	mTarOp(*mCont,ind...)
-    { }
-
-    // forward loop !!!!
-    template <typename T, class Op, class... Indices>
-    template <class ET>
-    inline const MultiArray<T,typename Indices::RangeType...>&
-    SliceContraction<T,Op,Indices...>::get(ET pos) const
-    {
-	*mCont = 0;
-	mOp.set(pos);
-	mTarOp = mOp;
-	return *mCont;
-    }
-
-    template <typename T, class Op, class... Indices>
-    template <class ET>
-    inline SliceContraction<T,Op,Indices...>& SliceContraction<T,Op,Indices...>::set(ET pos)
-    {
-	mOp.set(pos);
-	return *this;
-    }
-
-    template <typename T, class Op, class... Indices>
-    auto SliceContraction<T,Op,Indices...>::rootSteps(std::intptr_t iPtrNum) const
-	-> decltype(mOp.rootSteps(iPtrNum))
-    {
-	return mOp.rootSteps(iPtrNum);
-    }
-
-    template <typename T, class Op, class... Indices>
-    template <class Expr>
-    auto SliceContraction<T,Op,Indices...>::loop(Expr exp) const -> decltype(mOp.loop(exp))
-    {
-	return mOp.loop(exp);
-    }
-
 }
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 18e67e4..7ed20ef 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -57,10 +57,6 @@ namespace MultiArrayTools
 	auto sl(const std::shared_ptr<Indices>&... inds) const
 	    -> ConstSlice<T,typename Indices::RangeType...>;
 
-	template <class... Indices>
-	auto slc(const std::shared_ptr<Indices>&... inds) const
-	    -> SliceContraction<T,OperationClass,Indices...>;
-
 	template <class... Indices>
 	auto p(const std::shared_ptr<Indices>&... inds) const
 	    -> ConstOperationRoot<T,typename Indices::RangeType...>;
@@ -878,44 +874,47 @@ namespace MultiArrayTools
 	    -> decltype(mInd->iforh(1,mOp.loop(exp)));
     };
 
-    template <typename T, class Op, class... Indices>
-    //    class SliceContraction : public OperationTemplate
-    //<MultiArray<T,typename Indices::RangeType...>,
-    //SliceContraction<MultiArray<T,typename Indices::RangeType...>,Op,Indices...> >
-    class SliceContraction : public OperationTemplate<T,SliceContraction<T,Op,Indices...> >
+    // for SliceArray
+    template <typename T, class Op>
+    class HyperOperation : public OperationTemplate<T,HyperOperation<T,Op> >
     {
     public:
-	typedef MultiArray<T,typename Indices::RangeType...> value_type;
-	typedef OperationTemplate<T,SliceContraction<T,Op,Indices...> > OT;
+
+	typedef Op value_type;
+	typedef OperationTemplate<T,HyperOperation<T,Op> > OT;
 
 	static constexpr size_t SIZE = Op::SIZE;
         static constexpr bool CONT = false;
-	static constexpr bool VABLE = false;
-
+        static constexpr bool VABLE = false;
+        
     private:
 
-	mutable Op mOp;
-	mutable std::shared_ptr<MultiArray<T,typename Indices::RangeType...> > mCont;
-	mutable OperationRoot<T,typename Indices::RangeType...> mTarOp;
-		
+	Op mOp; // proto
+
     public:
-	typedef decltype(mOp.rootSteps(0)) ETuple;
-	
-	SliceContraction(const Op& op, std::shared_ptr<Indices>... ind);
+	//typedef decltype(mOp.rootSteps(0)) ETuple;
 	
 	template <class ET>
-	inline const value_type& get(ET pos) const;
+	// include ALL indices (external/internal!!!)
+	inline auto get(ET pos) const
+            -> decltype(mOp.template get<ET>(pos));
+
+	template <typename V, class ET>
+	inline auto vget(ET pos) const
+            -> decltype(mOp.template vget<V,ET>(pos));
 
 	template <class ET>
-	inline SliceContraction& set(ET pos);
+	inline HyperOperation& set(ET pos);
+
+	T* data() const { assert(0); return nullptr; }
 
 	auto rootSteps(std::intptr_t iPtrNum = 0) const  // nullptr for simple usage with decltype
 	    -> decltype(mOp.rootSteps(iPtrNum));
 
 	template <class Expr>
-	auto loop(Expr exp) const -> decltype(mOp.loop(exp)); // no loop
-	
-    };	
+	auto loop(Expr exp) const
+	    -> decltype(mInd->iforh(1,mOp.loop(exp)));
+    };
 }
 
 
diff --git a/src/tests/op_unit_test.cc b/src/tests/op_unit_test.cc
index c45891b..c0d0e5d 100644
--- a/src/tests/op_unit_test.cc
+++ b/src/tests/op_unit_test.cc
@@ -318,9 +318,6 @@ namespace
 	EXPECT_EQ( xround( res.at(mkt(mkt('3','b'),'A')) ), xround(2.911 + 0.373 + 1.470) );
 	EXPECT_EQ( xround( res.at(mkt(mkt('3','b'),'B')) ), xround(2.911 + 0.373 + 2.210) );
 
-	MultiArray<MultiArray<double,SRange,SRange>,SRange,SRange> ma7(sr2ptr,sr4ptr);
-	ma7(si1,si3) = ma4(si0,si1,si2,si3).slc(si0,si2);
-
 	si1->at('1');
 	si0->at('x');
 	(*si2) = 0;
@@ -335,34 +332,6 @@ namespace
 
 	EXPECT_EQ( xround( ma8.at(mkt('a','A')) ), xround( sl.at(mkt('A','a')) ) );
 	EXPECT_EQ( xround( ma8.at(mkt('b','A')) ), xround( sl.at(mkt('A','b')) ) );
-	
-	EXPECT_EQ( xround( ma7.at(mkt('1','A')).at(mkt('x','a')) ),
-		   xround( ma4.at(mkt('x','1','a','A')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('2','A')).at(mkt('x','a')) ),
-		   xround( ma4.at(mkt('x','2','a','A')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('3','A')).at(mkt('x','a')) ),
-		   xround( ma4.at(mkt('x','3','a','A')) ) );
-
-    	EXPECT_EQ( xround( ma7.at(mkt('1','A')).at(mkt('x','b')) ),
-		   xround( ma4.at(mkt('x','1','b','A')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('2','A')).at(mkt('x','b')) ),
-		   xround( ma4.at(mkt('x','2','b','A')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('3','A')).at(mkt('x','b')) ),
-		   xround( ma4.at(mkt('x','3','b','A')) ) );
-
-    	EXPECT_EQ( xround( ma7.at(mkt('1','A')).at(mkt('l','b')) ),
-		   xround( ma4.at(mkt('l','1','b','A')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('2','A')).at(mkt('l','b')) ),
-		   xround( ma4.at(mkt('l','2','b','A')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('3','A')).at(mkt('l','b')) ),
-		   xround( ma4.at(mkt('l','3','b','A')) ) );
-
-    	EXPECT_EQ( xround( ma7.at(mkt('1','B')).at(mkt('l','b')) ),
-		   xround( ma4.at(mkt('l','1','b','B')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('2','B')).at(mkt('l','b')) ),
-		   xround( ma4.at(mkt('l','2','b','B')) ) );
-	EXPECT_EQ( xround( ma7.at(mkt('3','B')).at(mkt('l','b')) ),
-		   xround( ma4.at(mkt('l','3','b','B')) ) );
     }
     
 } // anonymous namspace

From 24ea3c2c30251e3cb61ed8fe7a7bbeacf630d85a Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 30 Jun 2021 16:55:38 +0200
Subject: [PATCH 44/56] im com

---
 src/include/multi_array_operation.cc.h | 35 ++++++++------------------
 1 file changed, 11 insertions(+), 24 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 39e1d8d..956e702 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -135,9 +135,11 @@ namespace MultiArrayTools
 	return OperationPointer<T,OperationClass>(THIS());
     }
 
+    template <typename T, class OperationClass>
     template <class... Indices>
-    HyperOperation ho(const std::shared_ptr<Indices>& inds...) const
+    auto OperationBase<T,OperationClass>::ho(const std::shared_ptr<Indices>& inds...) const
     {
+        typedef XX SubOp;
 	return HyperOperation<T,SubOp,Indices...>()
     }
     
@@ -145,32 +147,17 @@ namespace MultiArrayTools
      *   AssignmentExpr     *
      ************************/
 
-    template <OpIndexAff OIA>
-    struct OpIndexResolve
-    {};
-    
-    template <>
-    struct OpIndexResolve<OpIndexAff::EXTERN>
+    template <OpIndexAff OIA, class ExtType>
+    inline size_t opIndexResolve(size_t start, ExtType last)
     {
-        
-        template <class ExtType>
-        static inline size_t get(size_t start, ExtType last)
-        {
+        if constexpr(OIA == OpIndexAff::EXTERN){
             return last.val();
         }
-        
-    };
-
-    template <>
-    struct OpIndexResolve<OpIndexAff::TARGET>
-    {
-        template <class ExtType>
-        static inline size_t get(size_t start, ExtType last)
-        {
+        if constexpr(OIA == OpIndexAff::TARGET){
             return start;
         }
-    };
-
+        return 0;
+    }
     
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
     AssignmentExpr<T,IOp,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
@@ -181,13 +168,13 @@ namespace MultiArrayTools
     {
         ExtType last = rootSteps();
 	last.zero();
-	IOp::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
+	IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
     }
 
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
     inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
-	IOp::f(mDataPtr,OpIndexResolve<OIA>::get(start,last),mSec,last.next());
+	IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
     }
     
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>

From 312074c486f6bb42302a63df16a13bdbac30a9c1 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 1 Jul 2021 00:42:31 +0200
Subject: [PATCH 45/56] multi_array_operation: remove RootSumN

---
 src/include/multi_array_operation.cc.h | 33 +++++++++++--
 src/include/multi_array_operation.h    | 64 +-------------------------
 2 files changed, 32 insertions(+), 65 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 956e702..e3b8161 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -134,7 +134,8 @@ namespace MultiArrayTools
     {
 	return OperationPointer<T,OperationClass>(THIS());
     }
-
+    
+    /*
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::ho(const std::shared_ptr<Indices>& inds...) const
@@ -142,6 +143,7 @@ namespace MultiArrayTools
         typedef XX SubOp;
 	return HyperOperation<T,SubOp,Indices...>()
     }
+    */
     
     /************************
      *   AssignmentExpr     *
@@ -208,16 +210,41 @@ namespace MultiArrayTools
 	static_assert(SIZE == sizeof...(Ops), "size missmatch");
     }
 
+    template <size_t N, class ExtType, class... Exprs>
+    inline size_t MOpGetX( ExtType last, const std::tuple<Exprs...>& etp)
+    {
+	if constexpr(N > 0){
+	    std::get<sizeof...(Exprs)-N-1>(etp).get(last);
+	    return MOpGetX<N-1>(last.next(),etp);
+	}
+	else {
+	    std::get<sizeof...(Exprs)-1>(etp).get(last);
+	    return 0;
+	}
+    }
+
+    template <size_t N, class ExtType, class... Exprs>
+    inline void MOpSetX( ExtType last, std::tuple<Exprs...>& etp)
+    {
+	if constexpr(N > 0){
+	    std::get<sizeof...(Exprs)-N-1>(etp).set(last);
+	    MOpSetX<N-1>(last.next(),etp);
+	}
+	else {
+	    std::get<sizeof...(Exprs)-1>(etp).set(last);
+	}
+    }
+
     template <typename T, class... Ops>
     inline size_t MOp<T,Ops...>::get(ExtType last) const
     {
-	return RootSumN<sizeof...(Ops)-1>::get(last,mOps.mOps);
+	return MOpGetX<sizeof...(Ops)-1>(last,mOps.mOps);
     }
 
     template <typename T, class... Ops>
     inline MOp<T,Ops...>& MOp<T,Ops...>::set(ExtType last)
     {
-	RootSumN<sizeof...(Ops)-1>::set(last,mOps.mOps);
+	MOpSetX<sizeof...(Ops)-1>(last,mOps.mOps);
 	return *this;
     }
     
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 7ed20ef..01126f6 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -99,68 +99,6 @@ namespace MultiArrayTools
 	friend OperationClass;
     };
 
-    template <size_t N>
-    struct RootSumN
-    {
-
-	template <class... Exprs>
-	static inline auto rootSteps(const std::tuple<Exprs...>& etp, std::intptr_t i)
-	{
-	    return RootSumN<N-1>::rootSteps(etp,i).extend( std::get<N>(etp).rootSteps(i) );
-	}
-
-	template <class ExtType, class... Exprs>
-	static inline void exec( size_t start, ExtType last, std::tuple<Exprs...>& etp)
-	{
-	    std::get<sizeof...(Exprs)-N-1>(etp)(start,last);
-	    RootSumN<N-1>::exec(start,last.next(),etp);
-	}
-
-	template <class ExtType, class... Exprs>
-	static inline size_t get( ExtType last, const std::tuple<Exprs...>& etp)
-	{
-	    std::get<sizeof...(Exprs)-N-1>(etp).get(last);
-	    return RootSumN<N-1>::get(last.next(),etp);
-	}
-
-	template <class ExtType, class... Exprs>
-	static inline void set( ExtType last, std::tuple<Exprs...>& etp)
-	{
-	    std::get<sizeof...(Exprs)-N-1>(etp).set(last);
-	    RootSumN<N-1>::set(last.next(),etp);
-	}
-    };
-
-    template <>
-    struct RootSumN<0>
-    {
-
-	template <class... Exprs>
-	static inline auto rootSteps(const std::tuple<Exprs...>& etp, std::intptr_t i)
-	{
-	    return std::get<0>(etp).rootSteps(i);
-	}
-
-	template <class ExtType, class... Exprs>
-	static inline void exec( size_t start, ExtType last, std::tuple<Exprs...>& etp)
-	{
-	    std::get<sizeof...(Exprs)-1>(etp)(start,last);
-	}
-
-	template <class ExtType, class... Exprs>
-	static inline size_t get( ExtType last, const std::tuple<Exprs...>& etp)
-	{
-	    std::get<sizeof...(Exprs)-1>(etp).get(last);
-	    return 0;
-	}
-
-	template <class ExtType, class... Exprs>
-	static inline void set( ExtType last, std::tuple<Exprs...>& etp)
-	{
-	    std::get<sizeof...(Exprs)-1>(etp).set(last);
-	}
-    };
-
     
     template <typename T>
     struct SelfIdentity
@@ -875,6 +813,7 @@ namespace MultiArrayTools
     };
 
     // for SliceArray
+    /*
     template <typename T, class Op>
     class HyperOperation : public OperationTemplate<T,HyperOperation<T,Op> >
     {
@@ -915,6 +854,7 @@ namespace MultiArrayTools
 	auto loop(Expr exp) const
 	    -> decltype(mInd->iforh(1,mOp.loop(exp)));
     };
+    */
 }
 
 

From e80c71aa620ce528b75fd6f63e0fb876d96ee44e Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 1 Jul 2021 01:51:10 +0200
Subject: [PATCH 46/56] multi_array_operation: member access class for
 array-type members -> sub operations...

---
 src/include/multi_array_operation.cc.h |  1 +
 src/include/multi_array_operation.h    | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index e3b8161..99ce205 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -170,6 +170,7 @@ namespace MultiArrayTools
     {
         ExtType last = rootSteps();
 	last.zero();
+	// TODO: ask MA container for data (ptr)!!!
 	IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
     }
 
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 01126f6..d90cbf7 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -145,9 +145,32 @@ namespace MultiArrayTools
     template <class F>
     using VFunc = decltype(mkVFunc(std::declval<F>()));
 
+    
+    template <typename T, class F, class... Indices>
+    class OpAccess
+    {
+    private:
+	std::tuple<std::shared_ptr<Indices>...> mInds;
+	
+    public:
+	static constexpr bool ISSTATIC = false;
+	
+	template <typename Op, class ExtType>
+	inline void operator()(T*& t, size_t pos, const Op& op, ExtType e)
+	{
+	    F::selfApply(t[pos](mInds), op.get(e)); // s.th. like that
+	    // TODO for classes related to the r.h.s.:
+	    // forward get(e) to elements returned by get(e) until basic types are reached
+	    // (also same for rootSteps etc...) !!!!
+	    // introduce traits !!!!
+	    // !!!!
+	}
+    };
+    
     template <typename T, class F>
     struct IAccess
     {
+	static constexpr bool ISSTATIC = true;
 	typedef T value_type;
 	typedef T in_type;
 	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
@@ -162,6 +185,7 @@ namespace MultiArrayTools
     template <typename T, class F>
     struct IVAccess
     {
+	static constexpr bool ISSTATIC = true;
 	typedef typename VType<T>::type value_type;
 	typedef T in_type;
 	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);

From bf7853c1b5f32108e471bcd286dd9cfa8d2b6fac Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 1 Jul 2021 17:55:46 +0200
Subject: [PATCH 47/56] operations: AccessTemplate (static base class)

---
 src/include/multi_array_operation.cc.h | 34 +++++++---
 src/include/multi_array_operation.h    | 87 ++++++++++++++++++++------
 2 files changed, 92 insertions(+), 29 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 99ce205..9e4e1fb 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -51,7 +51,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class IndexType>
     auto OperationBase<T,OperationClass>::c(const std::shared_ptr<IndexType>& ind) const
-	-> Contraction<T,OperationClass,IndexType>
     {
 	return Contraction<T,OperationClass,IndexType>(THIS(), ind);
     }
@@ -59,7 +58,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::sl(const std::shared_ptr<Indices>&... inds) const
-	-> ConstSlice<T,typename Indices::RangeType...>
     {
 	ConstSlice<T,typename Indices::RangeType...> out(inds->range()...);
 	out.define(inds...) = THIS();
@@ -69,7 +67,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::p(const std::shared_ptr<Indices>&... inds) const
-	-> ConstOperationRoot<T,typename Indices::RangeType...>
     {
 	auto ma = std::make_shared<MultiArray<T,typename Indices::RangeType...>>
 	    (inds->range()... , static_cast<T>(0));
@@ -80,7 +77,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::to(const std::shared_ptr<Indices>&... inds) const
-	-> MultiArray<T,typename Indices::RangeType...>
     {
 	MultiArray<T,typename Indices::RangeType...> out(inds->range()...);
 	out(inds...) = THIS();
@@ -90,7 +86,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::addto(const std::shared_ptr<Indices>&... inds) const
-	-> MultiArray<T,typename Indices::RangeType...>
     {
 	MultiArray<T,typename Indices::RangeType...> out(inds->range()...,
                                                          static_cast<T>(0));
@@ -101,7 +96,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::pto(const std::shared_ptr<Indices>&... inds) const
-	-> MultiArray<T,typename Indices::RangeType...>
     {
 	MultiArray<T,typename Indices::RangeType...> out(inds->range()...);
 	out(inds...).par() = THIS();
@@ -111,7 +105,6 @@ namespace MultiArrayTools
     template <typename T, class OperationClass>
     template <class... Indices>
     auto OperationBase<T,OperationClass>::paddto(const std::shared_ptr<Indices>&... inds) const
-	-> MultiArray<T,typename Indices::RangeType...>
     {
 	MultiArray<T,typename Indices::RangeType...> out(inds->range()...,
                                                          static_cast<T>(0));
@@ -123,14 +116,12 @@ namespace MultiArrayTools
     template <typename R, class... Args>
     auto OperationBase<T,OperationClass>::a(const std::shared_ptr<function<R,T,typename Args::value_type...>>& ll,
                                             const Args&... args) const
-        -> Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>
     {
         return Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>(ll, THIS(), args...);
     }
 
     template <typename T, class OperationClass>
     auto OperationBase<T,OperationClass>::ptr() const
-	-> OperationPointer<T,OperationClass>
     {
 	return OperationPointer<T,OperationClass>(THIS());
     }
@@ -144,7 +135,30 @@ namespace MultiArrayTools
 	return HyperOperation<T,SubOp,Indices...>()
     }
     */
-    
+
+    /************************
+     *   AccessTemplate     *
+     ************************/
+
+    template <class AccessClass>
+    auto AccessTemplate<AccessClass>::get(size_t pos)
+    {
+        return THIS().get(pos);
+    }
+
+    template <class AccessClass>
+    auto AccessTemplate<AccessClass>::get(size_t pos) const
+    {
+        return THIS().get(pos);
+    }
+
+    template <class AccessClass>
+    template <class F, typename Op, class ExtType>
+    void AccessTemplate<AccessClass>::exec(size_t pos, const Op& op, ExtType e) const
+    {
+        return THIS().template exec<F>(pos,op,e);
+    }
+
     /************************
      *   AssignmentExpr     *
      ************************/
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index d90cbf7..991302e 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -50,39 +50,30 @@ namespace MultiArrayTools
 	auto operator/(const OperationBase<U,Second>& in) const;
 
 	template <class IndexType>
-	auto c(const std::shared_ptr<IndexType>& ind) const
-	    -> Contraction<T,OperationClass,IndexType>;
+	auto c(const std::shared_ptr<IndexType>& ind) const;
 
 	template <class... Indices>
-	auto sl(const std::shared_ptr<Indices>&... inds) const
-	    -> ConstSlice<T,typename Indices::RangeType...>;
+	auto sl(const std::shared_ptr<Indices>&... inds) const;
 
 	template <class... Indices>
-	auto p(const std::shared_ptr<Indices>&... inds) const
-	    -> ConstOperationRoot<T,typename Indices::RangeType...>;
+	auto p(const std::shared_ptr<Indices>&... inds) const;
 
 	template <class... Indices>
-	auto to(const std::shared_ptr<Indices>&... inds) const
-	    -> MultiArray<T,typename Indices::RangeType...>;
+	auto to(const std::shared_ptr<Indices>&... inds) const;
 
         template <class... Indices>
-	auto addto(const std::shared_ptr<Indices>&... inds) const
-	    -> MultiArray<T,typename Indices::RangeType...>;
+	auto addto(const std::shared_ptr<Indices>&... inds) const;
 
         template <class... Indices>
-	auto pto(const std::shared_ptr<Indices>&... inds) const
-	    -> MultiArray<T,typename Indices::RangeType...>;
+	auto pto(const std::shared_ptr<Indices>&... inds) const;
 
         template <class... Indices>
-	auto paddto(const std::shared_ptr<Indices>&... inds) const
-	    -> MultiArray<T,typename Indices::RangeType...>;
+	auto paddto(const std::shared_ptr<Indices>&... inds) const;
 
         template <typename R, class... Args> // Args = Operation Classes
-        auto a(const std::shared_ptr<function<R,T,typename Args::value_type...>>& ll, const Args&... args) const
-            -> Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>;
+        auto a(const std::shared_ptr<function<R,T,typename Args::value_type...>>& ll, const Args&... args) const;
 
-	auto ptr() const
-	    -> OperationPointer<T,OperationClass>;
+	auto ptr() const;
 	
     private:		
 	friend OperationClass;
@@ -212,7 +203,65 @@ namespace MultiArrayTools
 
     template <typename T>
     using IVPlus = IVAccess<T,plus<T>>;
-    
+
+    // static polymorphism
+    template <class AccessClass>
+    class AccessTemplate
+    {
+    public:
+        typedef AccessClass AC;
+        
+        AccessClass& THIS() { return static_cast<AccessClass&>(*this); }
+        const AccessClass& THIS() const { return static_cast<const AccessClass&>(*this); }
+
+        inline auto get(size_t pos);
+        inline auto get(size_t pos) const;
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const;
+    };
+
+    template <typename T>
+    class PointerAccess : public AccessTemplate<PointerAccess<T>>
+    {
+    public:
+	typedef T value_type;
+	typedef T in_type;
+    private:
+        T* mPtr;
+        
+    public:
+        PointerAccess(T* ptr) : mPtr(ptr) {}
+        
+        T* get(size_t pos) { return mPtr; }
+        T* get(size_t pos) const { return mPtr; }
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const
+        {
+	    F::selfApply(*get(pos),op.get(e));
+        }
+    };
+
+    template <typename T>
+    class ConstPointerAccess : public AccessTemplate<ConstPointerAccess<T>>
+    {
+    public:
+	typedef T value_type;
+	typedef T in_type;
+    private:
+        const T* mPtr;
+        
+    public:
+        ConstPointerAccess(T* ptr) : mPtr(ptr) {}
+        
+        const T* get(size_t pos) { return mPtr; }
+        const T* get(size_t pos) const { return mPtr; }
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const { assert(0); }
+    };
+
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
     {

From 33b52c1a7005d86d76071a00c0cd4c693301ec45 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 1 Jul 2021 18:15:12 +0200
Subject: [PATCH 48/56] start building in Access classes + add IsArray trait

---
 src/include/multi_array_operation.cc.h | 34 ++++++++++++++++----------
 src/include/multi_array_operation.h    | 17 +++++++------
 src/include/statics/traits.h           | 26 ++++++++++++++++++++
 3 files changed, 57 insertions(+), 20 deletions(-)
 create mode 100644 src/include/statics/traits.h

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 9e4e1fb..2ccd7af 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -513,34 +513,38 @@ namespace MultiArrayTools
     OperationRoot<T,Ranges...>::
     OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
-	mDataPtr(ma.data()),
-        mOrigDataPtr(ma.data()),
+	//mDataPtr(ma.data()),
+        //mOrigDataPtr(ma.data()),
+        mDataAcc( ma.data(), ma.data() ),
 	mIndex( ma.begin() )
     {
 	mIndex(indices...);
-        mDataPtr = mOrigDataPtr + mIndex.pos();
+        mDataAcc.set( mIndex.pos() );
+        //mDataPtr = mOrigDataPtr + mIndex.pos();
     }
 
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
     OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
 		  const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices) :
-	mDataPtr(ma.data()),
-        mOrigDataPtr(ma.data()),
+	//mDataPtr(ma.data()),
+        //mOrigDataPtr(ma.data()),
 	mIndex( ma.begin() )
     {
 	mIndex(indices);
-        mDataPtr = mOrigDataPtr + mIndex.pos();
+        mDataAcc.set( mIndex.pos() );
+        //mDataPtr = mOrigDataPtr + mIndex.pos();
     }
 
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
     OperationRoot(T* data, const IndexType& ind) :
-	mDataPtr(data),
-        mOrigDataPtr(data),
+	//mDataPtr(data),
+        //mOrigDataPtr(data),
 	mIndex( ind )
     {
-        mDataPtr = mOrigDataPtr + mIndex.pos();
+        mDataAcc.set( mIndex.pos() );
+        //mDataPtr = mOrigDataPtr + mIndex.pos();
     }
 
     template <typename T, class... Ranges>
@@ -672,21 +676,24 @@ namespace MultiArrayTools
     template <class ET>
     inline T& OperationRoot<T,Ranges...>::get(ET pos) const
     {
-	return mDataPtr[pos.val()];
+        return *mDataAcc.get(pos.val());
+	//return mDataPtr[pos.val()];
     }
 
     template <typename T, class... Ranges>
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
+        return *(reinterpret_cast<V*>(mDataAcc.get(pos.val())));
+	//return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
 
     template <typename T, class... Ranges>
     template <class ET>
     inline OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::set(ET pos)
     {
-        mDataPtr = mOrigDataPtr + pos.val();
+        mDataAcc.set(pos.val());
+        //mDataPtr = mOrigDataPtr + pos.val();
 	return *this;
     }
 
@@ -706,7 +713,8 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     T* OperationRoot<T,Ranges...>::data() const
     {
-        return mDataPtr;
+        return mDataAcc.get(0);
+        //return mDataPtr;
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 991302e..a206c14 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -229,12 +229,14 @@ namespace MultiArrayTools
 	typedef T in_type;
     private:
         T* mPtr;
+        T* mOrigPtr;
         
     public:
-        PointerAccess(T* ptr) : mPtr(ptr) {}
+        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
         
-        T* get(size_t pos) { return mPtr; }
-        T* get(size_t pos) const { return mPtr; }
+        T* get(size_t pos) { return mPtr+pos; }
+        T* get(size_t pos) const { return mPtr+pos; }
+        PointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
 
 	template <class F, typename Op, class ExtType>
 	inline void exec(size_t pos, const Op& op, ExtType e) const
@@ -255,8 +257,8 @@ namespace MultiArrayTools
     public:
         ConstPointerAccess(T* ptr) : mPtr(ptr) {}
         
-        const T* get(size_t pos) { return mPtr; }
-        const T* get(size_t pos) const { return mPtr; }
+        const T* get(size_t pos) { return mPtr+pos; }
+        const T* get(size_t pos) const { return mPtr+pos; }
 
 	template <class F, typename Op, class ExtType>
 	inline void exec(size_t pos, const Op& op, ExtType e) const { assert(0); }
@@ -552,8 +554,9 @@ namespace MultiArrayTools
 
     private:
 
-	T* mDataPtr;
-        T* mOrigDataPtr;
+	//T* mDataPtr;
+        //T* mOrigDataPtr;
+        PointerAccess<T> mDataAcc;
 	IndexType mIndex;
 
     public:
diff --git a/src/include/statics/traits.h b/src/include/statics/traits.h
new file mode 100644
index 0000000..6bf12b5
--- /dev/null
+++ b/src/include/statics/traits.h
@@ -0,0 +1,26 @@
+
+#include "base_def.h"
+
+namespace MultiArrayTools
+{
+
+    template <typename T>
+    struct IsArray
+    {
+        static constexpr bool VALUE = false;
+    };
+
+#define add_array_trait(name) template <typename... X> struct IsArray<##name<X...>> { \
+        static constexpr bool VALUE = true; \
+    }
+
+    add_array_trait(MultiArrayBase);
+    add_array_trait(MutableMultiArrayBase);
+    add_array_trait(MultiArray);
+    add_array_trait(FunctionalMultiArray);
+    add_array_trait(Slice);
+    add_array_trait(ConstSlice);
+
+#undef add_array_trait
+
+}

From bf4633054dadc5d18e1013d8b36ac5228a1e4455 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 9 Jul 2021 16:54:30 +0200
Subject: [PATCH 49/56] im com (some weird runtime errors -> PointerAccess)

---
 src/include/multi_array_operation.cc.h | 132 +++++++++++++------------
 src/include/multi_array_operation.h    |  97 +++++++++---------
 2 files changed, 119 insertions(+), 110 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 2ccd7af..79a3568 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -152,6 +152,12 @@ namespace MultiArrayTools
         return THIS().get(pos);
     }
 
+    template <class AccessClass>
+    auto AccessTemplate<AccessClass>::oget(size_t pos) const
+    {
+	return THIS().oget(pos);
+    }
+
     template <class AccessClass>
     template <class F, typename Op, class ExtType>
     void AccessTemplate<AccessClass>::exec(size_t pos, const Op& op, ExtType e) const
@@ -174,47 +180,63 @@ namespace MultiArrayTools
         }
         return 0;
     }
-    
+    /*
     template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
     AssignmentExpr<T,IOp,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
         mTar(tar), mSec(sec), mDataPtr(dataPtr) {}
-    
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t start)
+    */
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
+        mTar(tar), mSec(sec), mDataAcc(dataAcc), mDataPtr(dataPtr) {}
+
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start)
     {
         ExtType last = rootSteps();
 	last.zero();
 	// TODO: ask MA container for data (ptr)!!!
-	IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
+	//mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+	assert(mDataAcc.get(0) != nullptr);
+	assert(mDataAcc.oget(0) != nullptr);
+	assert(mDataPtr == mDataAcc.oget(0));
+	IOp::f(mDataAcc.oget(0),opIndexResolve<OIA>(start,last),mSec,last.next());
+	//IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
     }
 
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
-	IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
+	//PointerAccess<T> pa(mDataPtr, mDataPtr);
+	//pa.template exec<IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+	//mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+	assert(mDataAcc.get(0) != nullptr);
+	assert(mDataAcc.oget(0) != nullptr);
+	assert(mDataPtr == mDataAcc.oget(0));
+	IOp::f(mDataAcc.oget(0),opIndexResolve<OIA>(start,last),mSec,last.next());
+	//IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
     }
     
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    typename AssignmentExpr<T,IOp,Target,OpClass,OIA>::ExtType
-    AssignmentExpr<T,IOp,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    typename AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::ExtType
+    AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
     {
 	return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
     }
 
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,IOp,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
     {
         (*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
     }
 
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr<T,IOp,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
     {
         return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
     }
 
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr<T,IOp,Target,OpClass,OIA>::dExtension() const
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::dExtension() const
     {
         return nullptr; //???!!!
     }
@@ -513,78 +535,72 @@ namespace MultiArrayTools
     OperationRoot<T,Ranges...>::
     OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
-	//mDataPtr(ma.data()),
-        //mOrigDataPtr(ma.data()),
+	mDataPtr(ma.data()),
+        mOrigDataPtr(ma.data()),
         mDataAcc( ma.data(), ma.data() ),
 	mIndex( ma.begin() )
     {
 	mIndex(indices...);
         mDataAcc.set( mIndex.pos() );
-        //mDataPtr = mOrigDataPtr + mIndex.pos();
+        mDataPtr = mOrigDataPtr + mIndex.pos();
     }
 
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
     OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
 		  const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices) :
-	//mDataPtr(ma.data()),
-        //mOrigDataPtr(ma.data()),
+	mDataPtr(ma.data()),
+        mOrigDataPtr(ma.data()),
+        mDataAcc( ma.data(), ma.data() ),
 	mIndex( ma.begin() )
     {
 	mIndex(indices);
         mDataAcc.set( mIndex.pos() );
-        //mDataPtr = mOrigDataPtr + mIndex.pos();
+        mDataPtr = mOrigDataPtr + mIndex.pos();
     }
 
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
     OperationRoot(T* data, const IndexType& ind) :
-	//mDataPtr(data),
-        //mOrigDataPtr(data),
+	mDataPtr(data),
+        mOrigDataPtr(data),
+        mDataAcc( data, data ),
 	mIndex( ind )
     {
         mDataAcc.set( mIndex.pos() );
-        //mDataPtr = mOrigDataPtr + mIndex.pos();
+        mDataPtr = mOrigDataPtr + mIndex.pos();
     }
 
     template <typename T, class... Ranges>
     template <class IOp, class OpClass>
     auto OperationRoot<T,Ranges...>::asx(const OpClass& in) const
-        -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
-
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
+        return mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+                                     (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
     template <class IOp, class OpClass>
     auto OperationRoot<T,Ranges...>::asxExpr(const OpClass& in) const
-        -> decltype(in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                            (mOrigDataPtr,*this,in)))
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                       (mOrigDataPtr,*this,in));
+        return in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
+                       (mOrigDataPtr,mDataAcc,*this,in));
     }
     
     template <typename T, class... Ranges>
     template <class IOp, class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                                      (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
+        return i->ifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
+                                 (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in) const
-        -> decltype(this->template asx<IAssign<T>>(in))
     {
         return this->template asx<IAssign<T>>(in);
     }
@@ -592,7 +608,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assignExpr(const OpClass& in) const
-        -> decltype(this->template asxExpr<IAssign<T>>(in))
     {
         return this->template asxExpr<IAssign<T>>(in);
     }
@@ -600,7 +615,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(this->template asx<IAssign<T>>(in,i))
     {
         return this->template asx<IAssign<T>>(in,i);
     }
@@ -608,7 +622,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in) const
-        -> decltype(this->template asx<IPlus<T>>(in))
     {
         return this->template asx<IPlus<T>>(in);
     }
@@ -616,7 +629,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(this->template asx<IPlus<T>>(in,i))
     {
         return this->template asx<IPlus<T>>(in,i);
     }
@@ -676,6 +688,7 @@ namespace MultiArrayTools
     template <class ET>
     inline T& OperationRoot<T,Ranges...>::get(ET pos) const
     {
+	assert(mDataAcc.get(pos.val()) == mDataPtr+pos.val());
         return *mDataAcc.get(pos.val());
 	//return mDataPtr[pos.val()];
     }
@@ -684,6 +697,7 @@ namespace MultiArrayTools
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
+	assert(mDataAcc.get(pos.val()) == mDataPtr+pos.val());
         return *(reinterpret_cast<V*>(mDataAcc.get(pos.val())));
 	//return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
@@ -693,7 +707,8 @@ namespace MultiArrayTools
     inline OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::set(ET pos)
     {
         mDataAcc.set(pos.val());
-        //mDataPtr = mOrigDataPtr + pos.val();
+        mDataPtr = mOrigDataPtr + pos.val();
+	assert(mDataAcc.get(0) == mDataPtr);
 	return *this;
     }
 
@@ -713,6 +728,7 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     T* OperationRoot<T,Ranges...>::data() const
     {
+	assert(mDataAcc.get(0) == mDataPtr);
         return mDataAcc.get(0);
         //return mDataPtr;
     }
@@ -737,6 +753,7 @@ namespace MultiArrayTools
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
+        mDataAcc( ma.data(), ma.data() ),
 	mIndex( ma.begin() )
     {
 	mIndex(indices...);
@@ -748,6 +765,7 @@ namespace MultiArrayTools
     ParallelOperationRoot(T* data, const IndexType& ind) :
 	mDataPtr(data),
         mOrigDataPtr(data),
+        mDataAcc( data, data ),
 	mIndex( ind )
     {
         mDataPtr = mOrigDataPtr + mIndex.pos();
@@ -756,41 +774,33 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class IOp, class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in) const
-        -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
-
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
+        return mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+				      (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
     template <class IOp, class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::asxExpr(const OpClass& in) const
-        -> decltype(in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                            (mOrigDataPtr,*this,in)))
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                       (mOrigDataPtr,*this,in));
+        return in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
+                       (mOrigDataPtr,mDataAcc,*this,in));
     }
     
     template <typename T, class... Ranges>
     template <class IOp, class OpClass, class Index>
     auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                      (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>())
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>();
+        return i->pifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
+                                 (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::assign(const OpClass& in) const
-        -> decltype(this->template asx<IAssign<T>>(in))
     {
         return this->template asx<IAssign<T>>(in);
     }
@@ -798,7 +808,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::assignExpr(const OpClass& in) const
-        -> decltype(this->template asxExpr<IAssign<T>>(in))
     {
         return this->template asxExpr<IAssign<T>>(in);
     }
@@ -806,7 +815,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto ParallelOperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(this->template asx<IAssign<T>>(in,i))
     {
         return this->template asx<IAssign<T>>(in,i);
     }
@@ -814,7 +822,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::plus(const OpClass& in) const
-        -> decltype(this->template asx<IPlus<T>>(in))
     {
         return this->template asx<IPlus<T>>(in);
     }
@@ -822,7 +829,6 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto ParallelOperationRoot<T,Ranges...>::plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-        -> decltype(this->template asx<IPlus<T>>(in,i))
     {
         return this->template asx<IPlus<T>>(in,i);
     }
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index a206c14..70115b5 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -133,9 +133,12 @@ namespace MultiArrayTools
 	// empty, implement corresponding constructors...!!!
     }
 
+    /*
     template <class F>
     using VFunc = decltype(mkVFunc(std::declval<F>()));
-
+    */
+    template <class F>
+    using VFunc = F;
     
     template <typename T, class F, class... Indices>
     class OpAccess
@@ -164,21 +167,26 @@ namespace MultiArrayTools
 	static constexpr bool ISSTATIC = true;
 	typedef T value_type;
 	typedef T in_type;
+	typedef F Func;
 	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
 
 	template <typename Op, class ExtType>
-	static inline void f(T*& t, size_t pos, const Op& op, ExtType e)
+	static inline void f(T* t, size_t pos, const Op& op, ExtType e)
 	{
 	    F::selfApply(t[pos],op.get(e));
 	}
     };
 
+    template <typename T, class F>
+    using IVAccess = IAccess<T,F>;
+    /*
     template <typename T, class F>
     struct IVAccess
     {
 	static constexpr bool ISSTATIC = true;
 	typedef typename VType<T>::type value_type;
 	typedef T in_type;
+	typedef VFunc<F> Func;
 	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
 
 	template <typename Op, class ExtType>
@@ -188,6 +196,7 @@ namespace MultiArrayTools
 	    VFunc<F>::selfApply(*reinterpret_cast<value_type*>(t+pos),op.template vget<value_type>(e));
 	}
     };
+    */
 
     template <typename T>
     using xxxplus = plus<T>;
@@ -216,9 +225,13 @@ namespace MultiArrayTools
 
         inline auto get(size_t pos);
         inline auto get(size_t pos) const;
+        inline auto oget(size_t pos) const;
 
 	template <class F, typename Op, class ExtType>
 	inline void exec(size_t pos, const Op& op, ExtType e) const;
+
+    protected:
+	AccessTemplate() = default;
     };
 
     template <typename T>
@@ -228,15 +241,22 @@ namespace MultiArrayTools
 	typedef T value_type;
 	typedef T in_type;
     private:
-        T* mPtr;
-        T* mOrigPtr;
+	PointerAccess() = default;
+	
+        T* mPtr = nullptr;
+        T* mOrigPtr = nullptr;
         
     public:
         PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
+	PointerAccess(const PointerAccess& in) = default;
+	PointerAccess(PointerAccess&& in) = default;
+	PointerAccess& operator=(const PointerAccess& in) = default;
+	PointerAccess& operator=(PointerAccess&& in) = default;
         
         T* get(size_t pos) { return mPtr+pos; }
         T* get(size_t pos) const { return mPtr+pos; }
         PointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
+        T* oget(size_t pos) const { return mOrigPtr+pos; }
 
 	template <class F, typename Op, class ExtType>
 	inline void exec(size_t pos, const Op& op, ExtType e) const
@@ -264,7 +284,7 @@ namespace MultiArrayTools
 	inline void exec(size_t pos, const Op& op, ExtType e) const { assert(0); }
     };
 
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
+    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
     {
     private:
@@ -272,6 +292,7 @@ namespace MultiArrayTools
 
         Target mTar;
         OpClass mSec;
+	AccessTemplate<AT> mDataAcc;
         T* mDataPtr;
             
     public:
@@ -281,7 +302,8 @@ namespace MultiArrayTools
         static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
         typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
 	    
-        AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec);
+        //AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec);
+	AssignmentExpr(T* dataPtr, const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec);
         AssignmentExpr(const AssignmentExpr& in) = default;
         AssignmentExpr(AssignmentExpr&& in) = default;
         AssignmentExpr& operator=(const AssignmentExpr& in) = default;
@@ -289,7 +311,7 @@ namespace MultiArrayTools
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
 	{
-	    return std::make_shared<AssignmentExpr<T,IOp,Target,OpClass,OIA>>(*this);
+	    return std::make_shared<AssignmentExpr<T,IOp,PointerAccess<T>,Target,OpClass,OIA>>(*this);
 	}
 	
         inline void operator()(size_t start = 0); 
@@ -303,10 +325,10 @@ namespace MultiArrayTools
     };
 
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    using AssignmentExpr2 = AssignmentExpr<T,IAssign<T>,Target,OpClass,OIA>;
+    using AssignmentExpr2 = AssignmentExpr<T,IAssign<T>,PointerAccess<T>,Target,OpClass,OIA>;
 
     template <typename T, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    using AddExpr = AssignmentExpr<T,IPlus<T>,Target,OpClass,OIA>;
+    using AddExpr = AssignmentExpr<T,IPlus<T>,PointerAccess<T>,Target,OpClass,OIA>;
 
     template <class... Ops>
     struct OperationTuple
@@ -554,8 +576,8 @@ namespace MultiArrayTools
 
     private:
 
-	//T* mDataPtr;
-        //T* mOrigDataPtr;
+	T* mDataPtr;
+        T* mOrigDataPtr;
         PointerAccess<T> mDataAcc;
 	IndexType mIndex;
 
@@ -569,38 +591,28 @@ namespace MultiArrayTools
 	OperationRoot(T* data, const IndexType& ind);
 
         template <class IOp, class OpClass>
-        auto asx(const OpClass& in) const
-            -> decltype(mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                              (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
+        auto asx(const OpClass& in) const;
 
         template <class IOp, class OpClass>
-        auto asxExpr(const OpClass& in) const
-            -> decltype(in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>(mOrigDataPtr,*this,in)));
+        auto asxExpr(const OpClass& in) const;
             
         template <class IOp, class OpClass, class Index>
-        auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const
-            -> decltype(i->ifor(1,in.loop(AssignmentExpr<T,IOp,OperationRoot<T,Ranges...>,OpClass>
-                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
+        auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const;
             
         template <class OpClass>
-        auto assign(const OpClass& in) const
-	    -> decltype(this->template asx<IAssign<T>>(in));
+        auto assign(const OpClass& in) const;
 
 	template <class OpClass>
-        auto assignExpr(const OpClass& in) const
-	    -> decltype(this->template asxExpr<IAssign<T>>(in));
+        auto assignExpr(const OpClass& in) const;
 	    
         template <class OpClass, class Index>
-        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-	    -> decltype(this->template asx<IAssign<T>>(in,i));
+        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const;
 	
 	template <class OpClass>
-        auto plus(const OpClass& in) const
-	    -> decltype(this->template asx<IPlus<T>>(in));
+        auto plus(const OpClass& in) const;
 
         template <class OpClass, class Index>
-        auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-	    -> decltype(this->template asx<IPlus<T>>(in,i));
+        auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const;
             
         template <class OpClass>
         OperationRoot& operator=(const OpClass& in);
@@ -652,6 +664,7 @@ namespace MultiArrayTools
 
 	T* mDataPtr;
         T* mOrigDataPtr;
+        PointerAccess<T> mDataAcc;
 	IndexType mIndex;
 
     public:
@@ -661,38 +674,28 @@ namespace MultiArrayTools
 	ParallelOperationRoot(T* data, const IndexType& ind);
 
         template <class IOp, class OpClass>
-        auto asx(const OpClass& in) const
-            -> decltype(mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                              (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
+        auto asx(const OpClass& in) const;
 
         template <class IOp, class OpClass>
-        auto asxExpr(const OpClass& in) const
-            -> decltype(in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>(mOrigDataPtr,*this,in)));
+        auto asxExpr(const OpClass& in) const;
             
         template <class IOp, class OpClass, class Index>
-        auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const
-            -> decltype(i->pifor(1,in.loop(AssignmentExpr<T,IOp,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                          (mOrigDataPtr,*this,in))).template vec<IOp::VSIZE>());
+        auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const;
             
         template <class OpClass>
-        auto assign(const OpClass& in) const
-	    -> decltype(this->template asx<IAssign<T>>(in));
+        auto assign(const OpClass& in) const;
 
 	template <class OpClass>
-        auto assignExpr(const OpClass& in) const
-	    -> decltype(this->template asxExpr<IAssign<T>>(in));
+        auto assignExpr(const OpClass& in) const;
 	    
         template <class OpClass, class Index>
-        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const
-	    -> decltype(this->template asx<IAssign<T>>(in,i));
+        auto assign(const OpClass& in, const std::shared_ptr<Index>& i) const;
 	
 	template <class OpClass>
-        auto plus(const OpClass& in) const
-	    -> decltype(this->template asx<IPlus<T>>(in));
+        auto plus(const OpClass& in) const;
 
         template <class OpClass, class Index>
-        auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const
-	    -> decltype(this->template asx<IPlus<T>>(in,i));
+        auto plus(const OpClass& in, const std::shared_ptr<Index>& i) const;
 
         template <class OpClass>
         ParallelOperationRoot& operator=(const OpClass& in);

From 8bde2d72504a0e8cf1509bd5404452d441ae2470 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 14 Jul 2021 22:01:07 +0200
Subject: [PATCH 50/56] fix bug from previous commit

---
 src/include/multi_array_operation.cc.h | 18 +++---------------
 src/include/multi_array_operation.h    | 16 ++++++++++++----
 2 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 79a3568..d6d44aa 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -187,7 +187,7 @@ namespace MultiArrayTools
     */
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
     AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
-        mTar(tar), mSec(sec), mDataAcc(dataAcc), mDataPtr(dataPtr) {}
+        mTar(tar), mSec(sec), mDataAcc(static_cast<const AT&>(dataAcc)), mDataPtr(dataPtr) {}
 
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
     inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start)
@@ -195,25 +195,13 @@ namespace MultiArrayTools
         ExtType last = rootSteps();
 	last.zero();
 	// TODO: ask MA container for data (ptr)!!!
-	//mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
-	assert(mDataAcc.get(0) != nullptr);
-	assert(mDataAcc.oget(0) != nullptr);
-	assert(mDataPtr == mDataAcc.oget(0));
-	IOp::f(mDataAcc.oget(0),opIndexResolve<OIA>(start,last),mSec,last.next());
-	//IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
+	mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
     }
 
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
     inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
-	//PointerAccess<T> pa(mDataPtr, mDataPtr);
-	//pa.template exec<IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
-	//mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
-	assert(mDataAcc.get(0) != nullptr);
-	assert(mDataAcc.oget(0) != nullptr);
-	assert(mDataPtr == mDataAcc.oget(0));
-	IOp::f(mDataAcc.oget(0),opIndexResolve<OIA>(start,last),mSec,last.next());
-	//IOp::f(mDataPtr,opIndexResolve<OIA>(start,last),mSec,last.next());
+	mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
     }
     
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 70115b5..ad5bc45 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -219,7 +219,12 @@ namespace MultiArrayTools
     {
     public:
         typedef AccessClass AC;
-        
+
+	AccessTemplate(const AccessTemplate& in) = default;
+	AccessTemplate(AccessTemplate&& in) = default;
+	AccessTemplate& operator=(const AccessTemplate& in) = default;
+	AccessTemplate& operator=(AccessTemplate&& in) = default;
+
         AccessClass& THIS() { return static_cast<AccessClass&>(*this); }
         const AccessClass& THIS() const { return static_cast<const AccessClass&>(*this); }
 
@@ -240,6 +245,8 @@ namespace MultiArrayTools
     public:
 	typedef T value_type;
 	typedef T in_type;
+
+	friend class AccessTemplate<PointerAccess<T>>;
     private:
 	PointerAccess() = default;
 	
@@ -247,12 +254,13 @@ namespace MultiArrayTools
         T* mOrigPtr = nullptr;
         
     public:
-        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
+        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr)
+	{ assert(mPtr != nullptr); assert(mOrigPtr != nullptr); }
 	PointerAccess(const PointerAccess& in) = default;
 	PointerAccess(PointerAccess&& in) = default;
 	PointerAccess& operator=(const PointerAccess& in) = default;
 	PointerAccess& operator=(PointerAccess&& in) = default;
-        
+
         T* get(size_t pos) { return mPtr+pos; }
         T* get(size_t pos) const { return mPtr+pos; }
         PointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
@@ -292,7 +300,7 @@ namespace MultiArrayTools
 
         Target mTar;
         OpClass mSec;
-	AccessTemplate<AT> mDataAcc;
+	AT mDataAcc;
         T* mDataPtr;
             
     public:

From a841782115eee3c8da06506e2fa5414c850551ea Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 18 Jul 2021 18:40:10 +0200
Subject: [PATCH 51/56] remove some old debug asserts

---
 src/include/multi_array_operation.cc.h | 29 ++++++++------------------
 src/include/multi_array_operation.h    | 26 +++--------------------
 2 files changed, 12 insertions(+), 43 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index d6d44aa..8bf41c8 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -180,14 +180,10 @@ namespace MultiArrayTools
         }
         return 0;
     }
-    /*
-    template <typename T, class IOp, class Target, class OpClass, OpIndexAff OIA>
-    AssignmentExpr<T,IOp,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
-        mTar(tar), mSec(sec), mDataPtr(dataPtr) {}
-    */
+
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::AssignmentExpr(T* dataPtr, const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
-        mTar(tar), mSec(sec), mDataAcc(static_cast<const AT&>(dataAcc)), mDataPtr(dataPtr) {}
+    AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
+        mTar(tar), mSec(sec), mDataAcc(static_cast<const AT&>(dataAcc)) {}
 
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
     inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start)
@@ -565,7 +561,7 @@ namespace MultiArrayTools
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+                                     (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -574,7 +570,7 @@ namespace MultiArrayTools
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
-                       (mOrigDataPtr,mDataAcc,*this,in));
+                       (mDataAcc,*this,in));
     }
     
     template <typename T, class... Ranges>
@@ -583,7 +579,7 @@ namespace MultiArrayTools
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return i->ifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+                                 (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -676,18 +672,14 @@ namespace MultiArrayTools
     template <class ET>
     inline T& OperationRoot<T,Ranges...>::get(ET pos) const
     {
-	assert(mDataAcc.get(pos.val()) == mDataPtr+pos.val());
         return *mDataAcc.get(pos.val());
-	//return mDataPtr[pos.val()];
     }
 
     template <typename T, class... Ranges>
     template <typename V, class ET>
     inline V& OperationRoot<T,Ranges...>::vget(ET pos) const
     {
-	assert(mDataAcc.get(pos.val()) == mDataPtr+pos.val());
         return *(reinterpret_cast<V*>(mDataAcc.get(pos.val())));
-	//return *(reinterpret_cast<V*>(mDataPtr+pos.val()));
     }
 
     template <typename T, class... Ranges>
@@ -696,7 +688,6 @@ namespace MultiArrayTools
     {
         mDataAcc.set(pos.val());
         mDataPtr = mOrigDataPtr + pos.val();
-	assert(mDataAcc.get(0) == mDataPtr);
 	return *this;
     }
 
@@ -716,9 +707,7 @@ namespace MultiArrayTools
     template <typename T, class... Ranges>
     T* OperationRoot<T,Ranges...>::data() const
     {
-	assert(mDataAcc.get(0) == mDataPtr);
         return mDataAcc.get(0);
-        //return mDataPtr;
     }
 
     template <typename T, class... Ranges>
@@ -765,7 +754,7 @@ namespace MultiArrayTools
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-				      (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+				      (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -774,7 +763,7 @@ namespace MultiArrayTools
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
-                       (mOrigDataPtr,mDataAcc,*this,in));
+                       (mDataAcc,*this,in));
     }
     
     template <typename T, class... Ranges>
@@ -783,7 +772,7 @@ namespace MultiArrayTools
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
         return i->pifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                 (mOrigDataPtr,mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+                                 (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
     }
 
     template <typename T, class... Ranges>
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index ad5bc45..2edb5c4 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -254,8 +254,8 @@ namespace MultiArrayTools
         T* mOrigPtr = nullptr;
         
     public:
-        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr)
-	{ assert(mPtr != nullptr); assert(mOrigPtr != nullptr); }
+        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
+	
 	PointerAccess(const PointerAccess& in) = default;
 	PointerAccess(PointerAccess&& in) = default;
 	PointerAccess& operator=(const PointerAccess& in) = default;
@@ -273,24 +273,6 @@ namespace MultiArrayTools
         }
     };
 
-    template <typename T>
-    class ConstPointerAccess : public AccessTemplate<ConstPointerAccess<T>>
-    {
-    public:
-	typedef T value_type;
-	typedef T in_type;
-    private:
-        const T* mPtr;
-        
-    public:
-        ConstPointerAccess(T* ptr) : mPtr(ptr) {}
-        
-        const T* get(size_t pos) { return mPtr+pos; }
-        const T* get(size_t pos) const { return mPtr+pos; }
-
-	template <class F, typename Op, class ExtType>
-	inline void exec(size_t pos, const Op& op, ExtType e) const { assert(0); }
-    };
 
     template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
@@ -301,7 +283,6 @@ namespace MultiArrayTools
         Target mTar;
         OpClass mSec;
 	AT mDataAcc;
-        T* mDataPtr;
             
     public:
 
@@ -310,8 +291,7 @@ namespace MultiArrayTools
         static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
         typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
 	    
-        //AssignmentExpr(T* dataPtr, const Target& tar, const OpClass& sec);
-	AssignmentExpr(T* dataPtr, const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec);
+	AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec);
         AssignmentExpr(const AssignmentExpr& in) = default;
         AssignmentExpr(AssignmentExpr&& in) = default;
         AssignmentExpr& operator=(const AssignmentExpr& in) = default;

From bba1c6944a4531c1b5b63549c15addb4e3ce2fa4 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Sun, 18 Jul 2021 23:11:05 +0200
Subject: [PATCH 52/56] im com (vectorization (wrong access instance) +
 parallel not working)

---
 src/include/multi_array_operation.cc.h | 114 +++++++++++++------------
 src/include/multi_array_operation.h    |  77 ++++++++++++-----
 2 files changed, 116 insertions(+), 75 deletions(-)

diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 8bf41c8..8a127d4 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -181,46 +181,46 @@ namespace MultiArrayTools
         return 0;
     }
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
         mTar(tar), mSec(sec), mDataAcc(static_cast<const AT&>(dataAcc)) {}
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start)
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t start)
     {
         ExtType last = rootSteps();
 	last.zero();
 	// TODO: ask MA container for data (ptr)!!!
-	mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+	mDataAcc.template exec<Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
     }
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
     {
-	mDataAcc.template exec<typename IOp::Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+	mDataAcc.template exec<Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
     }
     
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    typename AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::ExtType
-    AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    typename AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::ExtType
+    AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
     {
 	return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
     }
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
     {
         (*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
     }
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
     {
         return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
     }
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr<T,IOp,AT,Target,OpClass,OIA>::dExtension() const
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::dExtension() const
     {
         return nullptr; //???!!!
     }
@@ -556,95 +556,96 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Ranges>
-    template <class IOp, class OpClass>
+    template <class Func, class Access, class OpClass>
     auto OperationRoot<T,Ranges...>::asx(const OpClass& in) const
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return mIndex.ifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-                                     (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+	static_assert(Access::VSIZE > 0, "Access::VSIZE failed");
+	return mIndex.ifor(1,this->template asxExpr<Func,Access>(in)).template vec<Access::VSIZE>();
     }
 
     template <typename T, class... Ranges>
-    template <class IOp, class OpClass>
+    template <class Func, class Access, class OpClass>
     auto OperationRoot<T,Ranges...>::asxExpr(const OpClass& in) const
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
+        return in.loop(AssignmentExpr<T,Func,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
                        (mDataAcc,*this,in));
     }
     
     template <typename T, class... Ranges>
-    template <class IOp, class OpClass, class Index>
+    template <class Func, class Access, class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
     {
-        static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->ifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,OperationRoot<T,Ranges...>,OpClass>
-                                 (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+	static_assert(Access::VSIZE > 0, "Access::VSIZE failed");
+        return i->ifor(1,this->template asxExpr<Func,Access>(in)).template vec<Access::VSIZE>();
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in) const
     {
-        return this->template asx<IAssign<T>>(in);
+        return this->template asx<identity<T>,PointerAccess<T>>(in);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::assignExpr(const OpClass& in) const
     {
-        return this->template asxExpr<IAssign<T>>(in);
+        return this->template asxExpr<identity<T>,PointerAccess<T>>(in);
     }
     
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::assign(const OpClass& in, const std::shared_ptr<Index>& i) const
     {
-        return this->template asx<IAssign<T>>(in,i);
+        return this->template asx<identity<T>,PointerAccess<T>>(in,i);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in) const
     {
-        return this->template asx<IPlus<T>>(in);
+        return this->template asx<xxxplus<T>,PointerAccess<T>>(in);
     }
 
     template <typename T, class... Ranges>
     template <class OpClass, class Index>
     auto OperationRoot<T,Ranges...>::plus(const OpClass& in, const std::shared_ptr<Index>& i) const
     {
-        return this->template asx<IPlus<T>>(in,i);
+        return this->template asx<xxxplus<T>,PointerAccess<T>>(in,i);
     }
-
-    template <bool VABLE, template <typename> class F, typename TarOp, class OpClass>
+    
+    template <bool VABLE, class Func, typename TarOp, class OpClass>
     inline void vexec(TarOp& th, const OpClass& in)
     {
+	// VECTORIZATION!!!
+	// PARALLEL!!!
         if constexpr(VABLE){
             CHECK;
             typedef typename TarOp::value_type T;
-            auto x = th.template asx<IVAccess<T,F<T>>>(in);
-            if(x.rootSteps(x.vI()) == 1){
-                //if(0){
+            auto x = th.template asx<Func,VPointerAccess<T>>(in);
+            //if(x.rootSteps(x.vI()) == 1){
+	    if(0){
                 CHECK;
                 x();
             }
             else {
-                th.template asx<IAccess<T,F<T>>>(in)();
+                th.template asx<Func,PointerAccess<T>>(in)();
             }
         }
         else {
             typedef typename TarOp::value_type T;
-            IAccess<T,F<T>> tmp;
-            th.template asx<decltype(tmp)>(in)();
+            //IAccess<T,F<T>> tmp;
+            th.template asx<Func,PointerAccess<T>>(in)();
         }
     }
-
+    
     template <typename T, class... Ranges>
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator=(const OpClass& in)
     {
-	vexec<OpClass::VABLE,identity>(*this,in);
+	//asx<identity<T>>(in)();
+	vexec<OpClass::VABLE,identity<T>>(*this,in);
         return *this;
     }
 
@@ -652,7 +653,8 @@ namespace MultiArrayTools
     template <class OpClass>
     OperationRoot<T,Ranges...>& OperationRoot<T,Ranges...>::operator+=(const OpClass& in)
     {
-	vexec<OpClass::VABLE,xxxplus>(*this,in);
+	//asx<xxxplus<T>>(in)();
+	vexec<OpClass::VABLE,xxxplus<T>>(*this,in);
         return *this;
     }
 
@@ -661,13 +663,13 @@ namespace MultiArrayTools
     {
 	return operator=<OperationRoot<T,Ranges...> >(in);
     }
-
+    /*
     template <typename T, class... Ranges>
     ParallelOperationRoot<T,Ranges...> OperationRoot<T,Ranges...>::par()
     {
         return ParallelOperationRoot<T,Ranges...>(mOrigDataPtr, mIndex);
     }
-    
+    */
     template <typename T, class... Ranges>
     template <class ET>
     inline T& OperationRoot<T,Ranges...>::get(ET pos) const
@@ -722,7 +724,7 @@ namespace MultiArrayTools
 
     /*******************************
      *   ParallelOperationRoot     *
-     *******************************/
+     ******************************
     
     template <typename T, class... Ranges>
     ParallelOperationRoot<T,Ranges...>::
@@ -749,30 +751,30 @@ namespace MultiArrayTools
     }
 
     template <typename T, class... Ranges>
-    template <class IOp, class OpClass>
+    template <class Func, class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in) const
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return mIndex.pifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
-				      (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+        return mIndex.pifor(1,in.loop(AssignmentExpr<T,Func,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass,OpIndexAff::TARGET>
+				      (mDataAcc,*this,in))).template vec<Access::VSIZE>();
     }
 
     template <typename T, class... Ranges>
-    template <class IOp, class OpClass>
+    template <class Func, class OpClass>
     auto ParallelOperationRoot<T,Ranges...>::asxExpr(const OpClass& in) const
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
+        return in.loop(AssignmentExpr<T,Func,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
                        (mDataAcc,*this,in));
     }
     
     template <typename T, class... Ranges>
-    template <class IOp, class OpClass, class Index>
+    template <class Func, class OpClass, class Index>
     auto ParallelOperationRoot<T,Ranges...>::asx(const OpClass& in, const std::shared_ptr<Index>& i) const
     {
         static_assert( OpClass::SIZE == decltype(in.rootSteps())::SIZE, "Ext Size mismatch" );
-        return i->pifor(1,in.loop(AssignmentExpr<T,IOp,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
-                                 (mDataAcc,*this,in))).template vec<IOp::VSIZE>();
+        return i->pifor(1,in.loop(AssignmentExpr<T,Func,PointerAccess<T>,ParallelOperationRoot<T,Ranges...>,OpClass>
+                                 (mDataAcc,*this,in))).template vec<Access::VSIZE>();
     }
 
     template <typename T, class... Ranges>
@@ -837,7 +839,7 @@ namespace MultiArrayTools
     template <class ET>
     inline T& ParallelOperationRoot<T,Ranges...>::get(ET pos) const
     {
-	return mDataPtr[pos.val()/*+mOff*/];
+	return mDataPtr[pos.val()+mOff];
     }
 
     template <typename T, class... Ranges>
@@ -875,7 +877,7 @@ namespace MultiArrayTools
         auto i = mIndex;
 	return mOrigDataPtr + i().pos();
     }
-
+    */
 
     /************************
      *   OperationValue     *
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index 2edb5c4..da20604 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -133,12 +133,12 @@ namespace MultiArrayTools
 	// empty, implement corresponding constructors...!!!
     }
 
-    /*
+    
     template <class F>
     using VFunc = decltype(mkVFunc(std::declval<F>()));
-    */
-    template <class F>
-    using VFunc = F;
+    
+    //template <class F>
+    //using VFunc = F;
     
     template <typename T, class F, class... Indices>
     class OpAccess
@@ -177,9 +177,9 @@ namespace MultiArrayTools
 	}
     };
 
-    template <typename T, class F>
-    using IVAccess = IAccess<T,F>;
-    /*
+    //template <typename T, class F>
+    //using IVAccess = IAccess<T,F>;
+    
     template <typename T, class F>
     struct IVAccess
     {
@@ -196,7 +196,7 @@ namespace MultiArrayTools
 	    VFunc<F>::selfApply(*reinterpret_cast<value_type*>(t+pos),op.template vget<value_type>(e));
 	}
     };
-    */
+    
 
     template <typename T>
     using xxxplus = plus<T>;
@@ -246,6 +246,8 @@ namespace MultiArrayTools
 	typedef T value_type;
 	typedef T in_type;
 
+	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
+	
 	friend class AccessTemplate<PointerAccess<T>>;
     private:
 	PointerAccess() = default;
@@ -273,8 +275,45 @@ namespace MultiArrayTools
         }
     };
 
+    template <typename T>
+    class VPointerAccess : public AccessTemplate<VPointerAccess<T>>
+    {
+    public:
+	typedef typename VType<T>::type value_type;
+	typedef T in_type;
 
-    template <typename T, class IOp, class AT, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
+	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
+
+	friend class AccessTemplate<VPointerAccess<T>>;
+    private:
+	VPointerAccess() = default;
+	
+        T* mPtr = nullptr;
+        T* mOrigPtr = nullptr;
+        
+    public:
+        VPointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
+	
+	VPointerAccess(const VPointerAccess& in) = default;
+	VPointerAccess(VPointerAccess&& in) = default;
+	VPointerAccess& operator=(const VPointerAccess& in) = default;
+	VPointerAccess& operator=(VPointerAccess&& in) = default;
+
+        VType<T>* get(size_t pos) { return reinterpret_cast<VType<T>*>(mPtr+pos); }
+        VType<T>* get(size_t pos) const { return reinterpret_cast<VType<T>*>(mPtr+pos); }
+        VPointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
+        VType<T>* oget(size_t pos) const { return reinterpret_cast<VType<T>*>(mOrigPtr+pos); }
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const
+        {
+	    CHECK;
+	    F::selfApply(*get(pos),op.vget(e));
+        }
+    };
+
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
     class AssignmentExpr : public ExpressionBase
     {
     private:
@@ -299,7 +338,7 @@ namespace MultiArrayTools
 
 	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
 	{
-	    return std::make_shared<AssignmentExpr<T,IOp,PointerAccess<T>,Target,OpClass,OIA>>(*this);
+	    return std::make_shared<AssignmentExpr<T,Func,PointerAccess<T>,Target,OpClass,OIA>>(*this);
 	}
 	
         inline void operator()(size_t start = 0); 
@@ -578,13 +617,13 @@ namespace MultiArrayTools
 
 	OperationRoot(T* data, const IndexType& ind);
 
-        template <class IOp, class OpClass>
+        template <class Func, class Access, class OpClass>
         auto asx(const OpClass& in) const;
 
-        template <class IOp, class OpClass>
+        template <class Func, class Access, class OpClass>
         auto asxExpr(const OpClass& in) const;
             
-        template <class IOp, class OpClass, class Index>
+        template <class Func, class Access, class OpClass, class Index>
         auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const;
             
         template <class OpClass>
@@ -610,7 +649,7 @@ namespace MultiArrayTools
 
         OperationRoot& operator=(const OperationRoot& in);
         
-        ParallelOperationRoot<T,Ranges...> par();
+	auto par() { return *this; }
         
 	template <class ET>
 	inline T& get(ET pos) const;
@@ -633,7 +672,7 @@ namespace MultiArrayTools
 	    -> Slice<T,typename Indices::RangeType...>;
 
     };
-
+    /*
     template <typename T, class... Ranges>
     class ParallelOperationRoot : public OperationTemplate<T,ParallelOperationRoot<T,Ranges...> >
     {
@@ -661,13 +700,13 @@ namespace MultiArrayTools
 
 	ParallelOperationRoot(T* data, const IndexType& ind);
 
-        template <class IOp, class OpClass>
+        template <class Func, class OpClass>
         auto asx(const OpClass& in) const;
 
-        template <class IOp, class OpClass>
+        template <class Func, class OpClass>
         auto asxExpr(const OpClass& in) const;
             
-        template <class IOp, class OpClass, class Index>
+        template <class Func, class OpClass, class Index>
         auto asx(const OpClass& in, const std::shared_ptr<Index>& i) const;
             
         template <class OpClass>
@@ -710,7 +749,7 @@ namespace MultiArrayTools
 	T* data() const;
 
     };
-
+    */
     template <typename T>
     class OperationValue : public OperationTemplate<T,OperationValue<T> >
     {

From e3d4c34962acd7a689fc1884ab2344bae0044276 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 28 Jul 2021 19:55:37 +0200
Subject: [PATCH 53/56] rename files

---
 .../{multi_array_header.cc.h => cnorxz.cc.h}  |  8 +++---
 src/include/cnorxz.h                          | 20 ++++++++++++++
 src/include/conversions.h                     |  2 +-
 .../{multi_array.cc.h => cxz_array.cc.h}      |  2 +-
 src/include/{multi_array.h => cxz_array.h}    |  6 ++---
 ...ti_array_base.cc.h => cxz_array_base.cc.h} |  2 +-
 .../{multi_array_base.h => cxz_array_base.h}  |  4 +--
 ...rray_operation.cc.h => cxz_operation.cc.h} |  2 +-
 ...ulti_array_operation.h => cxz_operation.h} |  4 +--
 src/include/dynamic_operation.h               |  2 +-
 ...multi_array.cc.h => functional_array.cc.h} |  2 +-
 ...ional_multi_array.h => functional_array.h} |  6 ++---
 .../{hl_multi_array_header.h => hl_cnorxz.h}  |  0
 src/include/mbase_def.h                       | 26 +++++++++----------
 src/include/multi_array_header.h              | 20 --------------
 src/include/operation_def.h                   |  2 +-
 src/include/slice.h                           |  4 +--
 src/lib/high_level_operation.cc               |  4 +--
 src/lib/mk_hl_op.sh                           | 12 ++++-----
 src/tests/ma_unit_test.cc                     |  2 +-
 src/tests/op4_unit_test.cc                    |  2 +-
 src/tests/op_perf_test.cc                     |  2 +-
 src/tests/ranges/anonymous_unit_test.cc       |  2 +-
 src/tests/ranges/index_unit_test.cc           |  2 +-
 src/tests/test_header.h                       |  2 +-
 25 files changed, 70 insertions(+), 70 deletions(-)
 rename src/include/{multi_array_header.cc.h => cnorxz.cc.h} (64%)
 create mode 100644 src/include/cnorxz.h
 rename src/include/{multi_array.cc.h => cxz_array.cc.h} (99%)
 rename src/include/{multi_array.h => cxz_array.h} (98%)
 rename src/include/{multi_array_base.cc.h => cxz_array_base.cc.h} (99%)
 rename src/include/{multi_array_base.h => cxz_array_base.h} (98%)
 rename src/include/{multi_array_operation.cc.h => cxz_operation.cc.h} (99%)
 rename src/include/{multi_array_operation.h => cxz_operation.h} (99%)
 rename src/include/{functional_multi_array.cc.h => functional_array.cc.h} (98%)
 rename src/include/{functional_multi_array.h => functional_array.h} (94%)
 rename src/include/{hl_multi_array_header.h => hl_cnorxz.h} (100%)
 delete mode 100644 src/include/multi_array_header.h

diff --git a/src/include/multi_array_header.cc.h b/src/include/cnorxz.cc.h
similarity index 64%
rename from src/include/multi_array_header.cc.h
rename to src/include/cnorxz.cc.h
index 70a281d..a431fd2 100644
--- a/src/include/multi_array_header.cc.h
+++ b/src/include/cnorxz.cc.h
@@ -2,12 +2,12 @@
 #include "ranges/ranges_header.cc.h"
 
 #include "container_index.cc.h"
-#include "multi_array_operation.cc.h"
-#include "functional_multi_array.cc.h"
+#include "cxz_operation.cc.h"
+#include "functional_array.cc.h"
 #include "helper_tools.cc.h"
 #include "map_range.cc.h"
-#include "multi_array_base.cc.h"
-#include "multi_array.cc.h"
+#include "cxz_array_base.cc.h"
+#include "cxz_array.cc.h"
 #include "slice.cc.h"
 #include "dynamic_operation.cc.h"
 //#include "high_level_operation.cc.h"
diff --git a/src/include/cnorxz.h b/src/include/cnorxz.h
new file mode 100644
index 0000000..212af70
--- /dev/null
+++ b/src/include/cnorxz.h
@@ -0,0 +1,20 @@
+// -*- C++ -*-
+
+#ifndef __cnorxz_h__
+#define __cnorxz_h__
+
+#include <cstdlib>
+#include "container_index.h"
+#include "cxz_operation.h"
+#include "cxz_array_base.h"
+#include "cxz_array.h"
+#include "functional_array.h"
+#include "helper_tools.h"
+#include "operation_def.h"
+#include "map_range.h"
+#include "dynamic_operation.h"
+//#include "high_level_operation.h"
+
+#include "cnorxz.cc.h"
+
+#endif
diff --git a/src/include/conversions.h b/src/include/conversions.h
index 5cb06c7..14f3bc8 100644
--- a/src/include/conversions.h
+++ b/src/include/conversions.h
@@ -2,7 +2,7 @@
 #ifndef __ma_conversions_h__
 #define __ma_conversions_h__
 
-#include "multi_array.h"
+#include "cxz_array.h"
 #include "slice.h"
 
 namespace MultiArrayTools
diff --git a/src/include/multi_array.cc.h b/src/include/cxz_array.cc.h
similarity index 99%
rename from src/include/multi_array.cc.h
rename to src/include/cxz_array.cc.h
index 1601be3..8e95ec8 100644
--- a/src/include/multi_array.cc.h
+++ b/src/include/cxz_array.cc.h
@@ -1,5 +1,5 @@
 
-#include "multi_array.h"
+#include "cxz_array.h"
 #include "statics/static_for.h"
 
 namespace MultiArrayTools
diff --git a/src/include/multi_array.h b/src/include/cxz_array.h
similarity index 98%
rename from src/include/multi_array.h
rename to src/include/cxz_array.h
index 4fba5e9..265fb57 100644
--- a/src/include/multi_array.h
+++ b/src/include/cxz_array.h
@@ -1,11 +1,11 @@
 // -*- C++ -*-
 
-#ifndef __multi_array_h__
-#define __multi_array_h__
+#ifndef __cxz_array_h__
+#define __cxz_array_h__
 
 #include <algorithm>
 
-#include "multi_array_base.h"
+#include "cxz_array_base.h"
 #include "ranges/anonymous_range.h"
 
 namespace MultiArrayTools
diff --git a/src/include/multi_array_base.cc.h b/src/include/cxz_array_base.cc.h
similarity index 99%
rename from src/include/multi_array_base.cc.h
rename to src/include/cxz_array_base.cc.h
index 91b6993..9ad0ea9 100644
--- a/src/include/multi_array_base.cc.h
+++ b/src/include/cxz_array_base.cc.h
@@ -1,5 +1,5 @@
 
-#include "multi_array_base.h"
+#include "cxz_array_base.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/include/multi_array_base.h b/src/include/cxz_array_base.h
similarity index 98%
rename from src/include/multi_array_base.h
rename to src/include/cxz_array_base.h
index 1269cbc..71de4fa 100644
--- a/src/include/multi_array_base.h
+++ b/src/include/cxz_array_base.h
@@ -1,6 +1,6 @@
 
-#ifndef __multi_array_base_h__
-#define __multi_array_base_h__
+#ifndef __cxz_array_base_h__
+#define __cxz_array_base_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/multi_array_operation.cc.h b/src/include/cxz_operation.cc.h
similarity index 99%
rename from src/include/multi_array_operation.cc.h
rename to src/include/cxz_operation.cc.h
index 8a127d4..6d31809 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/cxz_operation.cc.h
@@ -1,5 +1,5 @@
 
-#include "multi_array_operation.h"
+#include "cxz_operation.h"
 #include "xfor/exttype.h"
 #include "ranges/range_helper.h"
 
diff --git a/src/include/multi_array_operation.h b/src/include/cxz_operation.h
similarity index 99%
rename from src/include/multi_array_operation.h
rename to src/include/cxz_operation.h
index da20604..6aeb0d6 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/cxz_operation.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __multi_array_operation_h__
-#define __multi_array_operation_h__
+#ifndef __cxz_operation_h__
+#define __cxz_operation_h__
 
 #include <cstdlib>
 #include <tuple>
diff --git a/src/include/dynamic_operation.h b/src/include/dynamic_operation.h
index 3835019..038b34e 100644
--- a/src/include/dynamic_operation.h
+++ b/src/include/dynamic_operation.h
@@ -3,7 +3,7 @@
 #define __dynamic_operation_h__
 
 #include "base_def.h"
-#include "multi_array_operation.h"
+#include "cxz_operation.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/include/functional_multi_array.cc.h b/src/include/functional_array.cc.h
similarity index 98%
rename from src/include/functional_multi_array.cc.h
rename to src/include/functional_array.cc.h
index 279cd5c..e0ae0a8 100644
--- a/src/include/functional_multi_array.cc.h
+++ b/src/include/functional_array.cc.h
@@ -1,5 +1,5 @@
 
-#include "functional_multi_array.h"
+#include "functional_array.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/include/functional_multi_array.h b/src/include/functional_array.h
similarity index 94%
rename from src/include/functional_multi_array.h
rename to src/include/functional_array.h
index 3652e24..65fc7bf 100644
--- a/src/include/functional_multi_array.h
+++ b/src/include/functional_array.h
@@ -1,8 +1,8 @@
 
-#ifndef __functional_multi_array__
-#define __functional_multi_array__
+#ifndef __functional_array__
+#define __functional_array__
 
-#include "multi_array_base.h"
+#include "cxz_array_base.h"
 #include "slice.h"
 
 namespace MultiArrayTools
diff --git a/src/include/hl_multi_array_header.h b/src/include/hl_cnorxz.h
similarity index 100%
rename from src/include/hl_multi_array_header.h
rename to src/include/hl_cnorxz.h
diff --git a/src/include/mbase_def.h b/src/include/mbase_def.h
index 1550c21..ccf3458 100644
--- a/src/include/mbase_def.h
+++ b/src/include/mbase_def.h
@@ -21,55 +21,55 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     class ConstContainerIndex;
 
-    // multi_array.h
+    // cxz_array.h
     template <typename T, class... SRanges>
     class MultiArrayBase;
 
-    // multi_array.h
+    // cxz_array.h
     template <typename T, class... SRanges>
     class MutableMultiArrayBase;
     
-    // multi_array.h
+    // cxz_array.h
     template <typename T, class... SRanges>
     class MultiArray;
    
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class OperationClass>
     class OperationBase;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class OperationClass>
     class OperationTemplate;
     
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class... Ranges>
     class OperationRoot;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class... Ranges>
     class ParallelOperationRoot;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T>
     class OperationValue;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class... Ranges>
     class ConstOperationRoot;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class Op>
     class OperationPointer;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class OpFunction, class... Ops>
     class Operation;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class Op, class IndexType>
     class Contraction;
 
-    // multi_array_operation.h
+    // cxz_operation.h
     template <typename T, class Op, class... Indices>
     class SliceContraction;
 
diff --git a/src/include/multi_array_header.h b/src/include/multi_array_header.h
deleted file mode 100644
index 05aa1a1..0000000
--- a/src/include/multi_array_header.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// -*- C++ -*-
-
-#ifndef __multi_array_header_h__
-#define __multi_array_header_h__
-
-#include <cstdlib>
-#include "container_index.h"
-#include "multi_array_operation.h"
-#include "multi_array_base.h"
-#include "multi_array.h"
-#include "functional_multi_array.h"
-#include "helper_tools.h"
-#include "operation_def.h"
-#include "map_range.h"
-#include "dynamic_operation.h"
-//#include "high_level_operation.h"
-
-#include "multi_array_header.cc.h"
-
-#endif
diff --git a/src/include/operation_def.h b/src/include/operation_def.h
index dd6aeed..adb6ca0 100644
--- a/src/include/operation_def.h
+++ b/src/include/operation_def.h
@@ -2,7 +2,7 @@
 #ifndef __operation_def_h__
 #define __operation_def_h__
 
-#include "multi_array_operation.h"
+#include "cxz_operation.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/include/slice.h b/src/include/slice.h
index ab7d196..16ed001 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -2,8 +2,8 @@
 #ifndef __slice_h__
 #define __slice_h__
 
-#include "multi_array_base.h"
-#include "multi_array_operation.h"
+#include "cxz_array_base.h"
+#include "cxz_operation.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/lib/high_level_operation.cc b/src/lib/high_level_operation.cc
index 2cc2938..187f922 100644
--- a/src/lib/high_level_operation.cc
+++ b/src/lib/high_level_operation.cc
@@ -1,6 +1,6 @@
 
-#include "multi_array_header.h"
-#include "hl_multi_array_header.h"
+#include "cnorxz.h"
+#include "hl_cnorxz.h"
 
 namespace MultiArrayTools
 {
diff --git a/src/lib/mk_hl_op.sh b/src/lib/mk_hl_op.sh
index 66514c3..e7cd329 100755
--- a/src/lib/mk_hl_op.sh
+++ b/src/lib/mk_hl_op.sh
@@ -9,8 +9,8 @@ for x in $(cat ../include/extensions/math.h) ; do
     fff=${xx%\)}
     file=hl_ops/${fff}.cc
     test -f ${file} && rm -f ${file}
-    echo "#include \"multi_array_header.h\"" >> ${file}
-    echo "#include \"hl_multi_array_header.h\"" >> ${file}
+    echo "#include \"cnorxz.h\"" >> ${file}
+    echo "#include \"hl_cnorxz.h\"" >> ${file}
     echo "" >> ${file}
     echo "namespace MultiArrayTools" >> ${file}
     echo "{" >> ${file}
@@ -24,8 +24,8 @@ done
 for fff in plus minus multiplies divides ; do
     file=hl_ops/${fff}.cc
     test -f ${file} && rm -f ${file}
-    echo "#include \"multi_array_header.h\"" >> ${file}
-    echo "#include \"hl_multi_array_header.h\"" >> ${file}
+    echo "#include \"cnorxz.h\"" >> ${file}
+    echo "#include \"hl_cnorxz.h\"" >> ${file}
     echo "" >> ${file}
     echo "namespace MultiArrayTools" >> ${file}
     echo "{" >> ${file}
@@ -37,8 +37,8 @@ done
 for fff in negate ; do
     file=hl_ops/${fff}.cc
     test -f ${file} && rm -f ${file}
-    echo "#include \"multi_array_header.h\"" >> ${file}
-    echo "#include \"hl_multi_array_header.h\"" >> ${file}
+    echo "#include \"cnorxz.h\"" >> ${file}
+    echo "#include \"hl_cnorxz.h\"" >> ${file}
     echo "" >> ${file}
     echo "namespace MultiArrayTools" >> ${file}
     echo "{" >> ${file}
diff --git a/src/tests/ma_unit_test.cc b/src/tests/ma_unit_test.cc
index 67f7b06..160caf8 100644
--- a/src/tests/ma_unit_test.cc
+++ b/src/tests/ma_unit_test.cc
@@ -4,7 +4,7 @@
 #include "gtest/gtest.h"
 #include <iostream>
 
-#include "multi_array_header.h"
+#include "cnorxz.h"
 
 namespace MAT = MultiArrayTools;
 
diff --git a/src/tests/op4_unit_test.cc b/src/tests/op4_unit_test.cc
index 313b79a..0dd6c16 100644
--- a/src/tests/op4_unit_test.cc
+++ b/src/tests/op4_unit_test.cc
@@ -1,6 +1,6 @@
 
 #include "test_header.h"
-#include "hl_multi_array_header.h"
+#include "hl_cnorxz.h"
 #include <ctime>
 
 namespace
diff --git a/src/tests/op_perf_test.cc b/src/tests/op_perf_test.cc
index 90c711d..084a6a8 100644
--- a/src/tests/op_perf_test.cc
+++ b/src/tests/op_perf_test.cc
@@ -4,7 +4,7 @@
 #include <iostream>
 #include <cassert>
 
-#include "multi_array_header.h"
+#include "cnorxz.h"
 #include "conversions.h"
 
 #include <ctime>
diff --git a/src/tests/ranges/anonymous_unit_test.cc b/src/tests/ranges/anonymous_unit_test.cc
index c2e6815..0b1a237 100644
--- a/src/tests/ranges/anonymous_unit_test.cc
+++ b/src/tests/ranges/anonymous_unit_test.cc
@@ -5,7 +5,7 @@
 #include <iostream>
 
 #include "ranges/rheader.h"
-#include "multi_array_header.h"
+#include "cnorxz.h"
 //#include "ranges/ranges_header.cc.h"
 
 namespace MAT = MultiArrayTools;
diff --git a/src/tests/ranges/index_unit_test.cc b/src/tests/ranges/index_unit_test.cc
index 77c24cd..6ab9959 100644
--- a/src/tests/ranges/index_unit_test.cc
+++ b/src/tests/ranges/index_unit_test.cc
@@ -4,7 +4,7 @@
 #include "gtest/gtest.h"
 #include <iostream>
 
-#include "multi_array_header.h"
+#include "cnorxz.h"
 
 namespace MAT = MultiArrayTools;
 
diff --git a/src/tests/test_header.h b/src/tests/test_header.h
index 0baab35..09b772c 100644
--- a/src/tests/test_header.h
+++ b/src/tests/test_header.h
@@ -4,7 +4,7 @@
 #include "gtest/gtest.h"
 #include <iostream>
 
-#include "multi_array_header.h"
+#include "cnorxz.h"
 
 #include <ctime>
 #include <cmath>

From c5e6003fc9e2aa45ea5823f6fcf42cbb3a824c06 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 28 Jul 2021 20:29:56 +0200
Subject: [PATCH 54/56] rename namespaces

---
 src/include/allocator.h                              | 10 +++++-----
 src/include/arith.cc.h                               |  2 +-
 src/include/arith.h                                  |  4 ++--
 src/include/basic_types.h                            |  2 +-
 src/include/container_index.cc.h                     |  4 ++--
 src/include/container_index.h                        |  4 ++--
 src/include/conversions.h                            |  2 +-
 src/include/cxz_array.cc.h                           |  2 +-
 src/include/cxz_array.h                              |  2 +-
 src/include/cxz_array_base.cc.h                      |  4 ++--
 src/include/cxz_array_base.h                         |  4 ++--
 src/include/cxz_operation.cc.h                       |  4 ++--
 src/include/cxz_operation.h                          |  4 ++--
 src/include/dynamic_operation.cc.h                   |  4 ++--
 src/include/dynamic_operation.h                      |  4 ++--
 src/include/functional_array.cc.h                    |  4 ++--
 src/include/functional_array.h                       |  4 ++--
 src/include/helper_tools.cc.h                        |  2 +-
 src/include/helper_tools.h                           | 10 +++++-----
 src/include/high_level_operation.cc.h                |  2 +-
 src/include/high_level_operation.h                   |  2 +-
 src/include/map_range.cc.h                           |  4 ++--
 src/include/map_range.h                              |  4 ++--
 src/include/map_range_factory_product_map.h          |  2 +-
 src/include/mbase_def.h                              |  2 +-
 src/include/operation_def.h                          |  2 +-
 src/include/ranges/anonymous_range.h                 |  8 ++++----
 src/include/ranges/dynamic_meta.h                    |  4 ++--
 src/include/ranges/dynamic_range.cc.h                |  8 ++++----
 src/include/ranges/dynamic_range.h                   |  8 ++++----
 src/include/ranges/index_base.h                      |  4 ++--
 src/include/ranges/index_type.h                      |  2 +-
 src/include/ranges/index_wrapper.cc.h                |  2 +-
 src/include/ranges/index_wrapper.h                   |  4 ++--
 src/include/ranges/multi_range.h                     |  8 ++++----
 src/include/ranges/multi_range_factory_product_map.h |  2 +-
 src/include/ranges/range_base.h                      |  4 ++--
 src/include/ranges/range_helper.h                    |  8 ++++----
 src/include/ranges/range_types/classic_range.h       |  2 +-
 src/include/ranges/range_types/null_range.h          |  2 +-
 src/include/ranges/range_types/space_range.h         |  2 +-
 src/include/ranges/range_types/spin_range.h          |  2 +-
 src/include/ranges/rbase_def.h                       |  2 +-
 src/include/ranges/single_range.h                    |  6 +++---
 src/include/ranges/subrange.h                        |  8 ++++----
 src/include/ranges/type_map.h                        |  2 +-
 src/include/ranges/value_range.h                     | 10 +++++-----
 src/include/ranges/x_to_string.h                     |  4 ++--
 src/include/slice.cc.h                               |  4 ++--
 src/include/slice.h                                  |  4 ++--
 src/include/statics/static_for.h                     |  4 ++--
 src/include/statics/traits.h                         |  2 +-
 src/include/type_operations.h                        |  6 +++---
 src/include/xfor/exttype.h                           |  8 ++++----
 src/include/xfor/for_type.h                          |  4 ++--
 src/include/xfor/for_utils.h                         |  4 ++--
 src/include/xfor/iloop.h                             |  2 +-
 src/include/xfor/xfor.h                              | 10 +++++-----
 src/lib/high_level_operation.cc                      |  2 +-
 src/lib/map_range_factory_product_map.cc             |  2 +-
 src/lib/mk_hl_op.sh                                  |  6 +++---
 src/lib/ranges/anonymous_range.cc                    |  4 ++--
 src/lib/ranges/dynamic_meta.cc                       |  4 ++--
 src/lib/ranges/dynamic_range.cc                      |  6 +++---
 src/lib/ranges/multi_range_factory_product_map.cc    |  2 +-
 src/lib/ranges/range_base.cc                         |  6 +++---
 src/lib/ranges/range_types/classic_range.cc          |  2 +-
 src/lib/ranges/range_types/null_range.cc             |  2 +-
 src/lib/ranges/range_types/space_range.cc            |  2 +-
 src/lib/ranges/range_types/spin_range.cc             |  2 +-
 src/lib/ranges/type_map.cc                           |  2 +-
 src/tests/ma_unit_test.cc                            |  2 +-
 src/tests/op_perf_test.cc                            |  2 +-
 src/tests/ranges/anonymous_unit_test.cc              |  2 +-
 src/tests/ranges/index_unit_test.cc                  |  2 +-
 src/tests/test_header.h                              |  2 +-
 76 files changed, 148 insertions(+), 148 deletions(-)

diff --git a/src/include/allocator.h b/src/include/allocator.h
index 5d66dac..f894381 100644
--- a/src/include/allocator.h
+++ b/src/include/allocator.h
@@ -12,7 +12,7 @@
 #define MIB_SIZE 1024*1024 // 1MiB
 #define WARN_SIZE MIB_SIZE*100 // 100 MiB
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
 
     template <typename T>
@@ -65,12 +65,12 @@ namespace MultiArrayHelper
     }
 
     
-} // namespace MultiArrayHelper
+} // namespace CNORXZInternal
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <typename T>
-    using vector = std::vector<T,MultiArrayHelper::Allocator<T>>;
+    using vector = std::vector<T,CNORXZInternal::Allocator<T>>;
 
     template <typename T>
     inline std::vector<T> toStdVec(const vector<T>& v)
@@ -84,6 +84,6 @@ namespace MultiArrayTools
         return vector<T>(v.begin(), v.end());
     }
     
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 #endif
diff --git a/src/include/arith.cc.h b/src/include/arith.cc.h
index 28dae5d..6eec6f4 100644
--- a/src/include/arith.cc.h
+++ b/src/include/arith.cc.h
@@ -1,7 +1,7 @@
 
 #include "arith.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <class F>
diff --git a/src/include/arith.h b/src/include/arith.h
index 6423911..10a865f 100644
--- a/src/include/arith.h
+++ b/src/include/arith.h
@@ -4,7 +4,7 @@
 
 #include <functional>
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     //template <typename T, class F, typename... As>
@@ -206,7 +206,7 @@ namespace MultiArrayTools
 	}
     };
 
-} // end namespace MultiArrayHelper
+} // end namespace CNORXZInternal
 
 #include "arith.cc.h"
 
diff --git a/src/include/basic_types.h b/src/include/basic_types.h
index 78884c3..0e0a9c7 100644
--- a/src/include/basic_types.h
+++ b/src/include/basic_types.h
@@ -3,7 +3,7 @@
 
 #include <string>
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     // just to fix this forever:
diff --git a/src/include/container_index.cc.h b/src/include/container_index.cc.h
index 1e8c333..20e79be 100644
--- a/src/include/container_index.cc.h
+++ b/src/include/container_index.cc.h
@@ -1,7 +1,7 @@
 
 #include "container_index.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     
     template <typename T, class... Indices>
@@ -437,4 +437,4 @@ namespace MultiArrayTools
 	return IB::mPos >= it.pos();
     }
 
-} // namespace MultiArrayTools
+} // namespace CNORXZ
diff --git a/src/include/container_index.h b/src/include/container_index.h
index 0dec151..c457e44 100644
--- a/src/include/container_index.h
+++ b/src/include/container_index.h
@@ -13,7 +13,7 @@
 #include "statics/static_for.h"
 #include "ranges/range_helper.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     
     template <typename T, class... Indices>
@@ -302,6 +302,6 @@ namespace MultiArrayTools
 	
     };
 
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
 #endif
diff --git a/src/include/conversions.h b/src/include/conversions.h
index 14f3bc8..76ffb87 100644
--- a/src/include/conversions.h
+++ b/src/include/conversions.h
@@ -5,7 +5,7 @@
 #include "cxz_array.h"
 #include "slice.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     namespace ConversionSizes
diff --git a/src/include/cxz_array.cc.h b/src/include/cxz_array.cc.h
index 8e95ec8..3d90a10 100644
--- a/src/include/cxz_array.cc.h
+++ b/src/include/cxz_array.cc.h
@@ -2,7 +2,7 @@
 #include "cxz_array.h"
 #include "statics/static_for.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <typename T>
     Scalar<T> scalar(const T& in)
diff --git a/src/include/cxz_array.h b/src/include/cxz_array.h
index 265fb57..97e98ad 100644
--- a/src/include/cxz_array.h
+++ b/src/include/cxz_array.h
@@ -8,7 +8,7 @@
 #include "cxz_array_base.h"
 #include "ranges/anonymous_range.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <typename T>
     struct ArrayCatter;
diff --git a/src/include/cxz_array_base.cc.h b/src/include/cxz_array_base.cc.h
index 9ad0ea9..f24c198 100644
--- a/src/include/cxz_array_base.cc.h
+++ b/src/include/cxz_array_base.cc.h
@@ -1,7 +1,7 @@
 
 #include "cxz_array_base.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
         
     /**********************
@@ -270,5 +270,5 @@ namespace MultiArrayTools
 	return ConstOperationRoot<T,MappedRanges...>(*this, inds...);
     }
 
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
diff --git a/src/include/cxz_array_base.h b/src/include/cxz_array_base.h
index 71de4fa..791215e 100644
--- a/src/include/cxz_array_base.h
+++ b/src/include/cxz_array_base.h
@@ -13,7 +13,7 @@
 
 #include "ranges/rheader.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <class IndexType>
@@ -178,7 +178,7 @@ namespace MultiArrayTools
     };
 
     
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
diff --git a/src/include/cxz_operation.cc.h b/src/include/cxz_operation.cc.h
index 6d31809..3d12cae 100644
--- a/src/include/cxz_operation.cc.h
+++ b/src/include/cxz_operation.cc.h
@@ -8,11 +8,11 @@
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
     
     /***************************
diff --git a/src/include/cxz_operation.h b/src/include/cxz_operation.h
index 6aeb0d6..6299e35 100644
--- a/src/include/cxz_operation.h
+++ b/src/include/cxz_operation.h
@@ -21,12 +21,12 @@
 
 #include "statics/static_for.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     template <typename T, class OperationClass>
diff --git a/src/include/dynamic_operation.cc.h b/src/include/dynamic_operation.cc.h
index fcb579a..c0f02fe 100644
--- a/src/include/dynamic_operation.cc.h
+++ b/src/include/dynamic_operation.cc.h
@@ -2,7 +2,7 @@
 #include "dynamic_operation.h"
 #include "helper_tools.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <typename T, class Operation>
     T DynamicOperation<T,Operation>::get(const DExtT& pos) const
@@ -195,4 +195,4 @@ namespace MultiArrayTools
         return std::make_shared<DynamicOuterOp<T,Operation,Ranges...>>(*this);
     }
 
-} // namespace MultiArrayTools
+} // namespace CNORXZ
diff --git a/src/include/dynamic_operation.h b/src/include/dynamic_operation.h
index 038b34e..08fed92 100644
--- a/src/include/dynamic_operation.h
+++ b/src/include/dynamic_operation.h
@@ -5,7 +5,7 @@
 #include "base_def.h"
 #include "cxz_operation.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <typename T>
@@ -204,6 +204,6 @@ namespace MultiArrayTools
 
     };
     */
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 #endif
diff --git a/src/include/functional_array.cc.h b/src/include/functional_array.cc.h
index e0ae0a8..02fb54e 100644
--- a/src/include/functional_array.cc.h
+++ b/src/include/functional_array.cc.h
@@ -1,7 +1,7 @@
 
 #include "functional_array.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
 
@@ -96,4 +96,4 @@ namespace MultiArrayTools
         return mkOperation( mFunc, MetaOperationRoot<SRanges>( inds ) ... );
     }
     
-} // namespace MultiArrayTools
+} // namespace CNORXZ
diff --git a/src/include/functional_array.h b/src/include/functional_array.h
index 65fc7bf..10112dc 100644
--- a/src/include/functional_array.h
+++ b/src/include/functional_array.h
@@ -5,7 +5,7 @@
 #include "cxz_array_base.h"
 #include "slice.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     
     template <typename T, class Function, class... SRanges>
@@ -51,7 +51,7 @@ namespace MultiArrayTools
     };
 
   
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
diff --git a/src/include/helper_tools.cc.h b/src/include/helper_tools.cc.h
index 8822929..957eb96 100644
--- a/src/include/helper_tools.cc.h
+++ b/src/include/helper_tools.cc.h
@@ -1,7 +1,7 @@
 
 #include "helper_tools.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <typename... T>
     std::ostream& operator<<(std::ostream& out, const std::tuple<T...>& tp)
diff --git a/src/include/helper_tools.h b/src/include/helper_tools.h
index e8906df..71f5788 100644
--- a/src/include/helper_tools.h
+++ b/src/include/helper_tools.h
@@ -9,7 +9,7 @@
 #include <functional>
 #include "xfor/iloop.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     
     template <typename... T>
@@ -173,16 +173,16 @@ namespace MultiArrayTools
     auto mkILoop(const OpTp& opTp, const IndTp& indTp, const VarTp& varTp, const LTp& lTp,
                  const std::array<size_t,std::tuple_size<LTp>::value>& umpos,
                  const std::array<size_t,std::tuple_size<VarTp>::value>& setzero)
-        -> MultiArrayHelper::ILoop<OpTp,IndTp,VarTp,LTp>
+        -> CNORXZInternal::ILoop<OpTp,IndTp,VarTp,LTp>
     {
-        return MultiArrayHelper::ILoop<OpTp,IndTp,VarTp,LTp>(opTp, indTp, varTp, lTp, umpos, setzero);
+        return CNORXZInternal::ILoop<OpTp,IndTp,VarTp,LTp>(opTp, indTp, varTp, lTp, umpos, setzero);
     }
 
     template <class CF>
     auto mkPILoop(const CF& cf)
-        -> MultiArrayHelper::PILoop<CF>
+        -> CNORXZInternal::PILoop<CF>
     {
-        return MultiArrayHelper::PILoop<CF>(cf);
+        return CNORXZInternal::PILoop<CF>(cf);
     }
 
     template <class IndexType>
diff --git a/src/include/high_level_operation.cc.h b/src/include/high_level_operation.cc.h
index 14643d7..b66440c 100644
--- a/src/include/high_level_operation.cc.h
+++ b/src/include/high_level_operation.cc.h
@@ -1,7 +1,7 @@
 
 #include "high_level_operation.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <typename T, class Op>
diff --git a/src/include/high_level_operation.h b/src/include/high_level_operation.h
index d3acf1f..71706fa 100644
--- a/src/include/high_level_operation.h
+++ b/src/include/high_level_operation.h
@@ -6,7 +6,7 @@
 #include "ranges/rheader.h"
 #include "dynamic_operation.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     typedef ClassicRange CR;
diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index d43c481..8cc780e 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -2,12 +2,12 @@
 #include "map_range.h"
 #include <type_traits>
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     /**************
diff --git a/src/include/map_range.h b/src/include/map_range.h
index ed70235..9532f2b 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -18,11 +18,11 @@
 
 #include "xfor/xfor.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
 
diff --git a/src/include/map_range_factory_product_map.h b/src/include/map_range_factory_product_map.h
index cd0eab9..cc89ed2 100644
--- a/src/include/map_range_factory_product_map.h
+++ b/src/include/map_range_factory_product_map.h
@@ -8,7 +8,7 @@
 #include "ranges/rbase_def.h"
 #include "mbase_def.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     class MapRangeFactoryProductMap
     {
diff --git a/src/include/mbase_def.h b/src/include/mbase_def.h
index ccf3458..39eb5a4 100644
--- a/src/include/mbase_def.h
+++ b/src/include/mbase_def.h
@@ -5,7 +5,7 @@
 #include "ranges/rbase_def.h"
 #include "allocator.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /***********************
      *  Provided Types     *
diff --git a/src/include/operation_def.h b/src/include/operation_def.h
index adb6ca0..287970c 100644
--- a/src/include/operation_def.h
+++ b/src/include/operation_def.h
@@ -4,7 +4,7 @@
 
 #include "cxz_operation.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <typename T, class OperationClass>
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index 9d4a4ab..031d0c0 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/src/include/ranges/anonymous_range.h
@@ -11,7 +11,7 @@
 #include "ranges/x_to_string.h"
 #include "ranges/type_map.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     typedef GenSingleIndex<size_t,SpaceType::ANON,MUI> AnonymousIndex;
@@ -133,7 +133,7 @@ namespace MultiArrayTools
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     /***********************
@@ -171,7 +171,7 @@ namespace MultiArrayTools
 
     std::shared_ptr<AnonymousRange> defaultRange(size_t size = 0);
 }
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace RangeHelper
     {
@@ -202,7 +202,7 @@ namespace MultiArrayTools
     }
 }
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /***********************
      *   AnonymousRange    *
diff --git a/src/include/ranges/dynamic_meta.h b/src/include/ranges/dynamic_meta.h
index 29346f7..51535aa 100644
--- a/src/include/ranges/dynamic_meta.h
+++ b/src/include/ranges/dynamic_meta.h
@@ -7,7 +7,7 @@
 
 #include "allocator.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     typedef std::pair<const char*,size_t> DynamicMetaElem;
@@ -66,6 +66,6 @@ namespace MultiArrayTools
     };
 
 
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 #endif
diff --git a/src/include/ranges/dynamic_range.cc.h b/src/include/ranges/dynamic_range.cc.h
index 99fc800..77bc659 100644
--- a/src/include/ranges/dynamic_range.cc.h
+++ b/src/include/ranges/dynamic_range.cc.h
@@ -1,11 +1,11 @@
 
 #include "ranges/dynamic_range.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-        using namespace MultiArrayHelper;
+        using namespace CNORXZInternal;
     }
 
 
@@ -186,9 +186,9 @@ namespace MultiArrayTools
     }
 
     
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace RangeHelper
     {
diff --git a/src/include/ranges/dynamic_range.h b/src/include/ranges/dynamic_range.h
index 8a9e6bf..f0075c6 100644
--- a/src/include/ranges/dynamic_range.h
+++ b/src/include/ranges/dynamic_range.h
@@ -17,11 +17,11 @@
 
 #include "index_wrapper.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     class DynamicIndex : public IndexInterface<DynamicIndex,vector<char>>
@@ -223,10 +223,10 @@ namespace MultiArrayTools
 
     };
 
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace RangeHelper
     {
diff --git a/src/include/ranges/index_base.h b/src/include/ranges/index_base.h
index 550aa08..9c0c4b2 100644
--- a/src/include/ranges/index_base.h
+++ b/src/include/ranges/index_base.h
@@ -13,7 +13,7 @@
 
 #include "xfor/xfor.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     
     template <class I, typename MetaType>
@@ -106,7 +106,7 @@ namespace MultiArrayTools
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /**********************
      *   IndexInterface   *
diff --git a/src/include/ranges/index_type.h b/src/include/ranges/index_type.h
index 6d8c52a..ac5e0fd 100644
--- a/src/include/ranges/index_type.h
+++ b/src/include/ranges/index_type.h
@@ -2,7 +2,7 @@
 #ifndef __index_type_h__
 #define __index_type_h__
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     enum class IndexType{
 	SINGLE = 0,
diff --git a/src/include/ranges/index_wrapper.cc.h b/src/include/ranges/index_wrapper.cc.h
index 9b734e9..20d180d 100644
--- a/src/include/ranges/index_wrapper.cc.h
+++ b/src/include/ranges/index_wrapper.cc.h
@@ -2,7 +2,7 @@
 #include "index_wrapper.h"
 #include "range_helper.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <class Index>
diff --git a/src/include/ranges/index_wrapper.h b/src/include/ranges/index_wrapper.h
index 3a58fd6..580412e 100644
--- a/src/include/ranges/index_wrapper.h
+++ b/src/include/ranges/index_wrapper.h
@@ -6,11 +6,11 @@
 #include "xfor/xfor.h"
 #include "ranges/rheader.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     class IndexWrapperBase
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 71c765e..3ab22d6 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -18,11 +18,11 @@
 
 #include "statics/static_for.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
     
     template <class... Indices>
@@ -218,12 +218,12 @@ namespace MultiArrayTools
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     // -> define in range_base.cc
diff --git a/src/include/ranges/multi_range_factory_product_map.h b/src/include/ranges/multi_range_factory_product_map.h
index e9dcb38..6630b1d 100644
--- a/src/include/ranges/multi_range_factory_product_map.h
+++ b/src/include/ranges/multi_range_factory_product_map.h
@@ -7,7 +7,7 @@
 #include <map>
 #include "ranges/rbase_def.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     class MultiRangeFactoryProductMap
     {
diff --git a/src/include/ranges/range_base.h b/src/include/ranges/range_base.h
index 8217797..a701e3d 100644
--- a/src/include/ranges/range_base.h
+++ b/src/include/ranges/range_base.h
@@ -9,12 +9,12 @@
 
 #include "rbase_def.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     class RangeBase;
 }
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     size_t indexId();
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 7c78c9b..53f1462 100644
--- a/src/include/ranges/range_helper.h
+++ b/src/include/ranges/range_helper.h
@@ -2,7 +2,7 @@
 #ifndef __range_helper_h__
 #define __range_helper_h__
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace RangeHelper
     {
@@ -167,7 +167,7 @@ namespace MultiArrayTools
 				     RangeTuple& rtp, size_t off, size_t size, SIZET... sizes)
 	{
 	    constexpr size_t tps = std::tuple_size<RangeTuple>::value;
-	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
+	    ::CNORXZ::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
 	    if constexpr(N < tps-1){
 		resolveRangeType<N+1>(orig, rtp, off+size, sizes...);
 	    }
@@ -178,7 +178,7 @@ namespace MultiArrayTools
 				     RangeTuple& rtp, size_t off, size_t size)
 	{
 	    constexpr size_t tps = std::tuple_size<RangeTuple>::value;
-	    ::MultiArrayTools::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
+	    ::CNORXZ::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
 	}
 
 	template <size_t N, class MetaType, class... Ranges>
@@ -280,6 +280,6 @@ namespace MultiArrayTools
 	}
 
     } // namespace RangeHelper
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 #endif
diff --git a/src/include/ranges/range_types/classic_range.h b/src/include/ranges/range_types/classic_range.h
index 6de6587..492d66a 100644
--- a/src/include/ranges/range_types/classic_range.h
+++ b/src/include/ranges/range_types/classic_range.h
@@ -10,7 +10,7 @@
 #ifndef __range_type_classic_def__
 #define __range_type_classic_def__
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     typedef GenSingleIndex<size_t,SpaceType::NONE,MUI> ClassicIndex;
 
diff --git a/src/include/ranges/range_types/null_range.h b/src/include/ranges/range_types/null_range.h
index 9776482..b87e39e 100644
--- a/src/include/ranges/range_types/null_range.h
+++ b/src/include/ranges/range_types/null_range.h
@@ -10,7 +10,7 @@ include_range_type(NUL,-2)
 #ifndef __range_type_null_def__
 #define __range_type_null_def__
 
-namespace MultiArrayTools
+namespace CNORXZ
 {   
     typedef GenSingleIndex<size_t,SpaceType::NUL,0> NullIndex;
 
diff --git a/src/include/ranges/range_types/space_range.h b/src/include/ranges/range_types/space_range.h
index 20022d5..badc9d7 100644
--- a/src/include/ranges/range_types/space_range.h
+++ b/src/include/ranges/range_types/space_range.h
@@ -8,7 +8,7 @@ include_range_type(PSPACE,3) // Periodic 1dim space
 #ifndef __range_type_space_def__
 #define __range_type_space_def__
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
      // Periodic 1dim space
     typedef GenSingleIndex<int,SpaceType::PSPACE,MUI> XSpaceIndex;
diff --git a/src/include/ranges/range_types/spin_range.h b/src/include/ranges/range_types/spin_range.h
index cf9b923..256f9be 100644
--- a/src/include/ranges/range_types/spin_range.h
+++ b/src/include/ranges/range_types/spin_range.h
@@ -10,7 +10,7 @@ include_range_type(SPIN,2)
 #ifndef __range_type_spin_def__
 #define __range_type_spin_def__
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     typedef GenSingleIndex<size_t,SpaceType::SPIN,4> SpinIndex;
 
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index 289b2b6..2aa04fa 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -17,7 +17,7 @@
 #include "allocator.h"
 #define MUI static_cast<size_t>(-1)
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <class R>
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index 643bfc0..17d5887 100644
--- a/src/include/ranges/single_range.h
+++ b/src/include/ranges/single_range.h
@@ -16,11 +16,11 @@
 
 #include "xfor/for_type.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     
@@ -327,7 +327,7 @@ namespace MultiArrayTools
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /******************
      *  GenSingleIndex   *	     
diff --git a/src/include/ranges/subrange.h b/src/include/ranges/subrange.h
index 3ec6d80..e34bea7 100644
--- a/src/include/ranges/subrange.h
+++ b/src/include/ranges/subrange.h
@@ -15,11 +15,11 @@
 
 #include "xfor/for_type.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     template <class Index>
@@ -154,9 +154,9 @@ namespace MultiArrayTools
         
     };
     
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     
     /*****************
diff --git a/src/include/ranges/type_map.h b/src/include/ranges/type_map.h
index 09c69f9..3f65c7b 100644
--- a/src/include/ranges/type_map.h
+++ b/src/include/ranges/type_map.h
@@ -10,7 +10,7 @@
 
 #include "allocator.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <size_t N>
diff --git a/src/include/ranges/value_range.h b/src/include/ranges/value_range.h
index e1e667c..db236e1 100644
--- a/src/include/ranges/value_range.h
+++ b/src/include/ranges/value_range.h
@@ -17,12 +17,12 @@
 
 #include "xfor/for_type.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
     
     template <typename U>
@@ -138,13 +138,13 @@ namespace MultiArrayTools
 	ValueRange() = default;
     };
     
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /*****************
      *  ValueIndex   *	     
@@ -410,6 +410,6 @@ namespace MultiArrayTools
     }
 
 
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 #endif
diff --git a/src/include/ranges/x_to_string.h b/src/include/ranges/x_to_string.h
index 5a28635..aa66616 100644
--- a/src/include/ranges/x_to_string.h
+++ b/src/include/ranges/x_to_string.h
@@ -10,7 +10,7 @@
 
 #include "ranges/dynamic_meta.h"
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
     template <typename T>
     inline std::string xToString(const T& x);
@@ -22,7 +22,7 @@ namespace MultiArrayHelper
     template <>
     inline std::string xToString<std::string>(const std::string& x);
 
-    using MultiArrayTools::DynamicMetaT;
+    using CNORXZ::DynamicMetaT;
     
     template <>
     inline std::string xToString<DynamicMetaT>(const DynamicMetaT& x);
diff --git a/src/include/slice.cc.h b/src/include/slice.cc.h
index 54235c3..5a118e3 100644
--- a/src/include/slice.cc.h
+++ b/src/include/slice.cc.h
@@ -1,7 +1,7 @@
 
 #include "slice.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     /*******************
@@ -296,5 +296,5 @@ namespace MultiArrayTools
     }
 
 
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
diff --git a/src/include/slice.h b/src/include/slice.h
index 16ed001..68b4c27 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -5,7 +5,7 @@
 #include "cxz_array_base.h"
 #include "cxz_operation.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <typename T, class... SRanges>
     class ConstSlice : public MultiArrayBase<T,SRanges...>
@@ -188,7 +188,7 @@ namespace MultiArrayTools
 	return SliceDef<T,Ranges...>::mkSlice(ind, op);
     }
 
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index b4a76e0..d8758ed 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -4,7 +4,7 @@
 
 #include <cstdlib>
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <size_t BEG, size_t END, int OFF, typename Incr, typename F>
     inline auto sfor(Incr incr, F f)
@@ -94,7 +94,7 @@ namespace MultiArrayTools
 #define MA_DEC [&](auto i) constexpr { return i-1; }
 #define MA_ZCONC [&](auto a, auto b) { return 0; }
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     template <size_t BEG, size_t END, typename F>
     inline auto sfor_p(F f)
diff --git a/src/include/statics/traits.h b/src/include/statics/traits.h
index 6bf12b5..2a97631 100644
--- a/src/include/statics/traits.h
+++ b/src/include/statics/traits.h
@@ -1,7 +1,7 @@
 
 #include "base_def.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     template <typename T>
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index be955d1..acebd59 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -13,11 +13,11 @@
 
 #include <cmath>
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-	using namespace MultiArrayHelper;
+	using namespace CNORXZInternal;
     }
 
     // MultiArray
@@ -518,6 +518,6 @@ namespace MultiArrayTools
 	return out;
     }
 
-} // namespace MultiArrayTools
+} // namespace CNORXZ
 
 #endif
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index a4b6a3a..fc72b50 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -4,7 +4,7 @@
 
 #include <array>
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
     
     struct None;
@@ -375,13 +375,13 @@ namespace MultiArrayHelper
 	return getX<I>(et).get();
     }
 
-} // end namespace MultiArrayHelper
+} // end namespace CNORXZInternal
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
 
     template <class X>
@@ -517,7 +517,7 @@ namespace MultiArrayHelper
 	return getX<N>(*this);
     }
 
-} // end namespace MultiArrayHelper
+} // end namespace CNORXZInternal
 
 
 #endif
diff --git a/src/include/xfor/for_type.h b/src/include/xfor/for_type.h
index 7ddaf18..7880ed7 100644
--- a/src/include/xfor/for_type.h
+++ b/src/include/xfor/for_type.h
@@ -2,7 +2,7 @@
 #ifndef __for_type_h__
 #define __for_type_h__
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
     
     enum class ForType {
@@ -17,7 +17,7 @@ namespace MultiArrayHelper
     class PFor;
 
     
-} // end namespace MultiArrayHelper
+} // end namespace CNORXZInternal
 
 
 #endif
diff --git a/src/include/xfor/for_utils.h b/src/include/xfor/for_utils.h
index 20679b0..5722d7e 100644
--- a/src/include/xfor/for_utils.h
+++ b/src/include/xfor/for_utils.h
@@ -6,7 +6,7 @@
 #include <array>
 #include <tuple>
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
     namespace {
         template <class Op>
@@ -34,6 +34,6 @@ namespace MultiArrayHelper
 
     };
     
-} // end namespace MultiArrayHelper
+} // end namespace CNORXZInternal
 
 #endif
diff --git a/src/include/xfor/iloop.h b/src/include/xfor/iloop.h
index 1afcc46..c54aaad 100644
--- a/src/include/xfor/iloop.h
+++ b/src/include/xfor/iloop.h
@@ -9,7 +9,7 @@
 #include <omp.h>
 #include "xfor.h"
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
     template <size_t N>
     struct NN
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 0b761b3..2125538 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -15,9 +15,9 @@
 #define VCHECK(a) std::cout << __FILE__ << ": @" << __LINE__ \
     << " in " << __func__ << ": " << #a << " = " << a << std::endl; 
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
-    using namespace MultiArrayTools;
+    using namespace CNORXZ;
     // 'HIDDEN FOR' CLASS for nested for loops in contractions a.s.o.
     // (NO COUNTING OF MASTER POSITION !!!!!)
 
@@ -562,7 +562,7 @@ namespace MultiArrayHelper
 
     };
 
-} // namespace MultiArrayHelper
+} // namespace CNORXZInternal
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
@@ -570,7 +570,7 @@ namespace MultiArrayHelper
 
 #include <iostream>
 
-namespace MultiArrayHelper
+namespace CNORXZInternal
 {
     template <class ExtType>
     const ExtType& ExtBase::expl() const
@@ -1035,6 +1035,6 @@ namespace MultiArrayHelper
 
 
     
-} // namespace MultiArrayHelper
+} // namespace CNORXZInternal
 
 #endif
diff --git a/src/lib/high_level_operation.cc b/src/lib/high_level_operation.cc
index 187f922..fd6a280 100644
--- a/src/lib/high_level_operation.cc
+++ b/src/lib/high_level_operation.cc
@@ -2,7 +2,7 @@
 #include "cnorxz.h"
 #include "hl_cnorxz.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     std::shared_ptr<DynamicIndex> mkSubSpaceX(const std::shared_ptr<DynamicIndex>& di,
 					      size_t max)
diff --git a/src/lib/map_range_factory_product_map.cc b/src/lib/map_range_factory_product_map.cc
index 28fbe39..0991b75 100644
--- a/src/lib/map_range_factory_product_map.cc
+++ b/src/lib/map_range_factory_product_map.cc
@@ -1,7 +1,7 @@
 
 #include "map_range_factory_product_map.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     std::map<std::shared_ptr<RangeBase>,vector<std::intptr_t> > MapRangeFactoryProductMap::mAleadyCreated;
 }
diff --git a/src/lib/mk_hl_op.sh b/src/lib/mk_hl_op.sh
index e7cd329..77c7ecd 100755
--- a/src/lib/mk_hl_op.sh
+++ b/src/lib/mk_hl_op.sh
@@ -12,7 +12,7 @@ for x in $(cat ../include/extensions/math.h) ; do
     echo "#include \"cnorxz.h\"" >> ${file}
     echo "#include \"hl_cnorxz.h\"" >> ${file}
     echo "" >> ${file}
-    echo "namespace MultiArrayTools" >> ${file}
+    echo "namespace CNORXZ" >> ${file}
     echo "{" >> ${file}
     echo "    template class HighLevelOp<OpCD,x_${fff}<double>,1>;" >> ${file}
     echo "    template class HighLevelOp<OpD,x_${fff}<double>,1>;" >> ${file}
@@ -27,7 +27,7 @@ for fff in plus minus multiplies divides ; do
     echo "#include \"cnorxz.h\"" >> ${file}
     echo "#include \"hl_cnorxz.h\"" >> ${file}
     echo "" >> ${file}
-    echo "namespace MultiArrayTools" >> ${file}
+    echo "namespace CNORXZ" >> ${file}
     echo "{" >> ${file}
     echo "    template class HighLevelOp<OpCD,${fff}x<double,double>,2>;" >> ${file}
     echo "    template class HighLevelOp<OpD,${fff}x<double,double>,2>;" >> ${file}
@@ -40,7 +40,7 @@ for fff in negate ; do
     echo "#include \"cnorxz.h\"" >> ${file}
     echo "#include \"hl_cnorxz.h\"" >> ${file}
     echo "" >> ${file}
-    echo "namespace MultiArrayTools" >> ${file}
+    echo "namespace CNORXZ" >> ${file}
     echo "{" >> ${file}
     echo "    template class HighLevelOp<OpCD,${fff}<double>,1>;" >> ${file}
     echo "    template class HighLevelOp<OpD,${fff}<double>,1>;" >> ${file}
diff --git a/src/lib/ranges/anonymous_range.cc b/src/lib/ranges/anonymous_range.cc
index c895763..9f2f652 100644
--- a/src/lib/ranges/anonymous_range.cc
+++ b/src/lib/ranges/anonymous_range.cc
@@ -3,7 +3,7 @@
 #include "ranges/ranges_header.cc.h"
 #include "ma_assert.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /******************************
      *   AnonymousRangeFactory    *
@@ -294,4 +294,4 @@ namespace MultiArrayTools
 
 
     
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
diff --git a/src/lib/ranges/dynamic_meta.cc b/src/lib/ranges/dynamic_meta.cc
index e25cb02..5422bdf 100644
--- a/src/lib/ranges/dynamic_meta.cc
+++ b/src/lib/ranges/dynamic_meta.cc
@@ -4,7 +4,7 @@
 #include "ranges/dynamic_meta.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
     /*********************
@@ -45,4 +45,4 @@ namespace MultiArrayTools
 
 
     
-} // namespace MultiArrayTools
+} // namespace CNORXZ
diff --git a/src/lib/ranges/dynamic_range.cc b/src/lib/ranges/dynamic_range.cc
index 6227486..fc02940 100644
--- a/src/lib/ranges/dynamic_range.cc
+++ b/src/lib/ranges/dynamic_range.cc
@@ -3,11 +3,11 @@
 #include "ranges/ranges_header.cc.h"
 #include "ma_assert.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     namespace
     {
-        using namespace MultiArrayHelper;
+        using namespace CNORXZInternal;
     }
 
 
@@ -484,5 +484,5 @@ namespace MultiArrayTools
         return mOrig;
     }
     
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
 
diff --git a/src/lib/ranges/multi_range_factory_product_map.cc b/src/lib/ranges/multi_range_factory_product_map.cc
index 7a072cb..1597ddf 100644
--- a/src/lib/ranges/multi_range_factory_product_map.cc
+++ b/src/lib/ranges/multi_range_factory_product_map.cc
@@ -2,7 +2,7 @@
 #include "ranges/multi_range_factory_product_map.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     std::map<std::shared_ptr<RangeBase>,vector<std::intptr_t> > MultiRangeFactoryProductMap::mAleadyCreated;
 }
diff --git a/src/lib/ranges/range_base.cc b/src/lib/ranges/range_base.cc
index 6e6448a..ba8a3be 100644
--- a/src/lib/ranges/range_base.cc
+++ b/src/lib/ranges/range_base.cc
@@ -11,10 +11,10 @@
 
 #include <algorithm>
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 
-    //using namespace MultiArrayHelpers;
+    //using namespace CNORXZInternals;
 
     template <class... Ranges>
     using STP = std::tuple<std::shared_ptr<Ranges>...>;
@@ -215,4 +215,4 @@ namespace MultiArrayTools
         return reinterpret_cast<std::intptr_t>(this);
     }
 
-} // end namespace MultiArrayTools
+} // end namespace CNORXZ
diff --git a/src/lib/ranges/range_types/classic_range.cc b/src/lib/ranges/range_types/classic_range.cc
index 790332d..73a0a22 100644
--- a/src/lib/ranges/range_types/classic_range.cc
+++ b/src/lib/ranges/range_types/classic_range.cc
@@ -3,7 +3,7 @@
 #include "ranges/x_to_string.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     /********************
      *   GenSingleRange    *
diff --git a/src/lib/ranges/range_types/null_range.cc b/src/lib/ranges/range_types/null_range.cc
index 5c0db14..6dc79cc 100644
--- a/src/lib/ranges/range_types/null_range.cc
+++ b/src/lib/ranges/range_types/null_range.cc
@@ -3,7 +3,7 @@
 #include "ranges/x_to_string.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     std::shared_ptr<NullRF> mkNUL(const char* dp, size_t size)
     {
diff --git a/src/lib/ranges/range_types/space_range.cc b/src/lib/ranges/range_types/space_range.cc
index efc7fe6..39a3257 100644
--- a/src/lib/ranges/range_types/space_range.cc
+++ b/src/lib/ranges/range_types/space_range.cc
@@ -3,7 +3,7 @@
 #include "ranges/x_to_string.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     std::shared_ptr<PSpaceRF> mkPSPACE(const char* dp, size_t size)
     {
diff --git a/src/lib/ranges/range_types/spin_range.cc b/src/lib/ranges/range_types/spin_range.cc
index 26791f1..40770fd 100644
--- a/src/lib/ranges/range_types/spin_range.cc
+++ b/src/lib/ranges/range_types/spin_range.cc
@@ -3,7 +3,7 @@
 #include "ranges/x_to_string.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
     std::shared_ptr<SpinRF> mkSPIN(const char* dp, size_t size)
     {
diff --git a/src/lib/ranges/type_map.cc b/src/lib/ranges/type_map.cc
index 730ade8..9796b38 100644
--- a/src/lib/ranges/type_map.cc
+++ b/src/lib/ranges/type_map.cc
@@ -2,7 +2,7 @@
 #include "ranges/type_map.h"
 #include "ranges/ranges_header.cc.h"
 
-namespace MultiArrayTools
+namespace CNORXZ
 {
 #define XCOMMAX() ,
 #define include_type(t,n) template struct TypeMap<n>; \
diff --git a/src/tests/ma_unit_test.cc b/src/tests/ma_unit_test.cc
index 160caf8..bc85a74 100644
--- a/src/tests/ma_unit_test.cc
+++ b/src/tests/ma_unit_test.cc
@@ -6,7 +6,7 @@
 
 #include "cnorxz.h"
 
-namespace MAT = MultiArrayTools;
+namespace MAT = CNORXZ;
 
 namespace {
 
diff --git a/src/tests/op_perf_test.cc b/src/tests/op_perf_test.cc
index 084a6a8..6e32837 100644
--- a/src/tests/op_perf_test.cc
+++ b/src/tests/op_perf_test.cc
@@ -13,7 +13,7 @@
 
 #define ONLY_SPIN
 
-namespace MAT = MultiArrayTools;
+namespace MAT = CNORXZ;
 
 namespace {
 
diff --git a/src/tests/ranges/anonymous_unit_test.cc b/src/tests/ranges/anonymous_unit_test.cc
index 0b1a237..7507de8 100644
--- a/src/tests/ranges/anonymous_unit_test.cc
+++ b/src/tests/ranges/anonymous_unit_test.cc
@@ -8,7 +8,7 @@
 #include "cnorxz.h"
 //#include "ranges/ranges_header.cc.h"
 
-namespace MAT = MultiArrayTools;
+namespace MAT = CNORXZ;
 
 namespace {
 
diff --git a/src/tests/ranges/index_unit_test.cc b/src/tests/ranges/index_unit_test.cc
index 6ab9959..1f84272 100644
--- a/src/tests/ranges/index_unit_test.cc
+++ b/src/tests/ranges/index_unit_test.cc
@@ -6,7 +6,7 @@
 
 #include "cnorxz.h"
 
-namespace MAT = MultiArrayTools;
+namespace MAT = CNORXZ;
 
 namespace {
 
diff --git a/src/tests/test_header.h b/src/tests/test_header.h
index 09b772c..f41d3a1 100644
--- a/src/tests/test_header.h
+++ b/src/tests/test_header.h
@@ -9,7 +9,7 @@
 #include <ctime>
 #include <cmath>
 
-namespace MAT = MultiArrayTools;
+namespace MAT = CNORXZ;
 
 double xround(double arg)
 {

From 3975edea2089b430488e563ab57694bd3ea05b6e Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 28 Jul 2021 20:59:31 +0200
Subject: [PATCH 55/56] rename MultiArray + pre-processor variables

---
 src/include/allocator.h                       |  4 +-
 src/include/arith.h                           |  4 +-
 src/include/base_def.h                        |  4 +-
 src/include/basic_types.h                     |  4 +-
 src/include/cnorxz.h                          |  4 +-
 src/include/container_index.h                 |  4 +-
 src/include/conversions.h                     |  8 +-
 src/include/cxz_array.cc.h                    | 80 +++++++++----------
 src/include/cxz_array.h                       | 70 ++++++++--------
 src/include/cxz_array_base.cc.h               | 76 +++++++++---------
 src/include/cxz_array_base.h                  | 46 +++++------
 src/include/{ma_assert.h => cxz_assert.h}     |  0
 src/include/cxz_operation.cc.h                | 20 ++---
 src/include/cxz_operation.h                   | 12 +--
 src/include/dynamic_operation.cc.h            | 12 +--
 src/include/dynamic_operation.h               |  8 +-
 src/include/functional_array.cc.h             | 34 ++++----
 src/include/functional_array.h                | 22 ++---
 src/include/helper_tools.cc.h                 | 36 ++++-----
 src/include/helper_tools.h                    | 34 ++++----
 src/include/high_level_operation.h            |  4 +-
 src/include/map_range.cc.h                    | 12 +--
 src/include/map_range.h                       | 14 ++--
 src/include/map_range_factory_product_map.h   |  4 +-
 src/include/mbase_def.h                       | 10 +--
 src/include/operation_def.h                   |  4 +-
 src/include/ranges/anonymous_range.h          |  4 +-
 src/include/ranges/dynamic_meta.h             |  4 +-
 src/include/ranges/dynamic_range.h            |  4 +-
 src/include/ranges/index_base.h               |  4 +-
 src/include/ranges/index_type.h               |  4 +-
 src/include/ranges/index_wrapper.h            |  4 +-
 src/include/ranges/multi_range.h              |  4 +-
 .../ranges/multi_range_factory_product_map.h  |  4 +-
 src/include/ranges/range_base.h               |  4 +-
 src/include/ranges/range_helper.h             |  4 +-
 .../ranges/range_types/classic_range.h        | 10 +--
 src/include/ranges/range_types/header.h       | 14 ++--
 src/include/ranges/range_types/null_range.h   | 10 +--
 src/include/ranges/range_types/space_range.h  | 10 +--
 src/include/ranges/range_types/spin_range.h   | 10 +--
 src/include/ranges/rbase_def.h                |  4 +-
 src/include/ranges/reg_ind_num.h              |  4 +-
 src/include/ranges/rheader.h                  |  4 +-
 src/include/ranges/rpheader.h                 |  4 +-
 src/include/ranges/single_range.h             |  4 +-
 src/include/ranges/subrange.h                 |  4 +-
 src/include/ranges/type_map.h                 |  4 +-
 src/include/ranges/value_range.h              |  4 +-
 src/include/ranges/x_to_string.h              |  4 +-
 src/include/slice.cc.h                        | 18 ++---
 src/include/slice.h                           | 32 ++++----
 src/include/statics/static_for.h              |  4 +-
 src/include/statics/traits.h                  |  8 +-
 src/include/type_operations.h                 | 12 +--
 src/include/xfor/exttype.h                    |  4 +-
 src/include/xfor/for_type.h                   |  4 +-
 src/include/xfor/for_utils.h                  |  4 +-
 src/include/xfor/iloop.h                      |  4 +-
 src/include/xfor/xfor.h                       |  4 +-
 src/lib/ranges/anonymous_range.cc             |  2 +-
 src/lib/ranges/dynamic_range.cc               |  2 +-
 src/tests/CMakeLists.txt                      |  4 +-
 .../{ma_unit_test.cc => array_unit_test.cc}   | 12 +--
 src/tests/op2_unit_test.cc                    | 24 +++---
 src/tests/op3_unit_test.cc                    |  8 +-
 src/tests/op4_unit_test.cc                    | 12 +--
 src/tests/op_perf_test.cc                     | 14 ++--
 src/tests/op_unit_test.cc                     | 76 +++++++++---------
 69 files changed, 454 insertions(+), 454 deletions(-)
 rename src/include/{ma_assert.h => cxz_assert.h} (100%)
 rename src/tests/{ma_unit_test.cc => array_unit_test.cc} (94%)

diff --git a/src/include/allocator.h b/src/include/allocator.h
index f894381..56ca670 100644
--- a/src/include/allocator.h
+++ b/src/include/allocator.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_allocator__
-#define __ma_allocator__
+#ifndef __cxz_allocator__
+#define __cxz_allocator__
 
 #include <cstdlib>
 #include <new>
diff --git a/src/include/arith.h b/src/include/arith.h
index 10a865f..74b1230 100644
--- a/src/include/arith.h
+++ b/src/include/arith.h
@@ -1,6 +1,6 @@
 
-#ifndef __arith_h__
-#define __arith_h__
+#ifndef __cxz_arith_h__
+#define __cxz_arith_h__
 
 #include <functional>
 
diff --git a/src/include/base_def.h b/src/include/base_def.h
index 9628956..d5d87da 100644
--- a/src/include/base_def.h
+++ b/src/include/base_def.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __base_def_h__
-#define __base_def_h__
+#ifndef __cxz_base_def_h__
+#define __cxz_base_def_h__
 
 #include <cassert>
 
diff --git a/src/include/basic_types.h b/src/include/basic_types.h
index 0e0a9c7..0c806be 100644
--- a/src/include/basic_types.h
+++ b/src/include/basic_types.h
@@ -1,5 +1,5 @@
-#ifndef __basic_types_h__
-#define __basic_types_h__
+#ifndef __cxz_basic_types_h__
+#define __cxz_basic_types_h__
 
 #include <string>
 
diff --git a/src/include/cnorxz.h b/src/include/cnorxz.h
index 212af70..6a655a5 100644
--- a/src/include/cnorxz.h
+++ b/src/include/cnorxz.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __cnorxz_h__
-#define __cnorxz_h__
+#ifndef __cxz_cnorxz_h__
+#define __cxz_cnorxz_h__
 
 #include <cstdlib>
 #include "container_index.h"
diff --git a/src/include/container_index.h b/src/include/container_index.h
index c457e44..c47d1d6 100644
--- a/src/include/container_index.h
+++ b/src/include/container_index.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __container_index_h__
-#define __container_index_h__
+#ifndef __cxz_container_index_h__
+#define __cxz_container_index_h__
 
 #include <cstdlib>
 #include <tuple>
diff --git a/src/include/conversions.h b/src/include/conversions.h
index 76ffb87..2b1dc78 100644
--- a/src/include/conversions.h
+++ b/src/include/conversions.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_conversions_h__
-#define __ma_conversions_h__
+#ifndef __cxz_conversions_h__
+#define __cxz_conversions_h__
 
 #include "cxz_array.h"
 #include "slice.h"
@@ -94,7 +94,7 @@ namespace CNORXZ
     }
 
     template <typename C, typename T, class... Ranges>
-    auto tcast(MultiArray<T,Ranges...>& ma)
+    auto tcast(Array<T,Ranges...>& ma)
 	-> decltype(rangeTpToSlice
 	    ( rtcast<C,T>( ma.range()->space() ),
 	      reinterpret_cast<C*>( ma.data() ) ))
@@ -107,7 +107,7 @@ namespace CNORXZ
     }
     
     template <typename C, typename T, class... Ranges>
-    auto tcast(const MultiArray<T,Ranges...>& ma)
+    auto tcast(const Array<T,Ranges...>& ma)
 	-> decltype(rangeTpToSlice
 	    ( rtcast<C,T>( ma.range()->space() ),
 	      reinterpret_cast<const C*>( ma.data() ) ))
diff --git a/src/include/cxz_array.cc.h b/src/include/cxz_array.cc.h
index 3d90a10..797a991 100644
--- a/src/include/cxz_array.cc.h
+++ b/src/include/cxz_array.cc.h
@@ -12,21 +12,21 @@ namespace CNORXZ
     }
     
     /*******************
-     *  MultiArray     *	     
+     *  Array     *	     
      *******************/
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const typename CRange::Space& space) :
-	MutableMultiArrayBase<T,SRanges...>(space),
+    Array<T,SRanges...>::Array(const typename CRange::Space& space) :
+	MutableArrayBase<T,SRanges...>(space),
 	mCont(MAB::mRange->size())
     {
 	MAB::mInit = true;
     }
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const typename CRange::Space& space,
+    Array<T,SRanges...>::Array(const typename CRange::Space& space,
 					 const vector<T>& vec) :
-	MutableMultiArrayBase<T,SRanges...>(space),
+	MutableArrayBase<T,SRanges...>(space),
 	mCont(vec)
     {
 	MAB::mInit = true;
@@ -37,24 +37,24 @@ namespace CNORXZ
 
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges) :
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(MAB::mRange->size())
     {
 	MAB::mInit = true;
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, const T& val) : 
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, const T& val) : 
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(MAB::mRange->size(), val)
     {
 	MAB::mInit = true;
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec) :
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(vec)
     {
 	MAB::mInit = true;
@@ -64,8 +64,8 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec) :
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(std::forward<vector<T>>(vec))
     {
 	MAB::mInit = true;
@@ -76,8 +76,8 @@ namespace CNORXZ
 
     template <typename T, class... SRanges>
     template <class... Ranges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, MultiArray<T,Ranges...>&& in) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, Array<T,Ranges...>&& in) :
+	MutableArrayBase<T,SRanges...>(ranges...),
         mCont( std::move( in.mCont ) )
     {
         // maybe some checks here in the future...
@@ -87,8 +87,8 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(MultiArray<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes) :
-	MutableMultiArrayBase<T,SRanges...>
+    Array<T,SRanges...>::Array(Array<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes) :
+	MutableArrayBase<T,SRanges...>
 	( ama.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ),
 	mCont( std::move( ama.mCont ) )
     {
@@ -97,85 +97,85 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    T& MultiArray<T,SRanges...>::operator[](const IndexType& i)
+    T& Array<T,SRanges...>::operator[](const IndexType& i)
     {
 	return mCont[ i.pos() ];
     }
 
     template <typename T, class... SRanges>
-    const T& MultiArray<T,SRanges...>::operator[](const IndexType& i) const
+    const T& Array<T,SRanges...>::operator[](const IndexType& i) const
     {
 	return mCont[ i.pos() ];
     }
 
     template <typename T, class... SRanges>
-    T& MultiArray<T,SRanges...>::at(const typename IndexType::MetaType& meta)
+    T& Array<T,SRanges...>::at(const typename IndexType::MetaType& meta)
     {
 	return mCont[ MAB::cbegin().at(meta).pos() ];
     }
 
     template <typename T, class... SRanges>
-    const T& MultiArray<T,SRanges...>::at(const typename IndexType::MetaType& meta) const
+    const T& Array<T,SRanges...>::at(const typename IndexType::MetaType& meta) const
     {
 	return mCont[ MAB::cbegin().at(meta).pos() ];
     }
 	
     template <typename T, class... SRanges>
-    bool MultiArray<T,SRanges...>::isConst() const
+    bool Array<T,SRanges...>::isConst() const
     {
 	return false;
     }
     
     template <typename T, class... SRanges>
-    bool MultiArray<T,SRanges...>::isSlice() const
+    bool Array<T,SRanges...>::isSlice() const
     {
 	return false;
     }
 
     template <typename T, class... SRanges>
     template <class... SRanges2>
-    MultiArray<T,SRanges2...> MultiArray<T,SRanges...>::format(const std::shared_ptr<SRanges2>&... nrs)
+    Array<T,SRanges2...> Array<T,SRanges...>::format(const std::shared_ptr<SRanges2>&... nrs)
     {
 	//MAB::mInit = false;
-	return MultiArray<T,SRanges2...>( nrs... , mCont );
+	return Array<T,SRanges2...>( nrs... , mCont );
     }
 
     template <typename T, class... SRanges>
     template <class... SRanges2>
-    MultiArray<T,SRanges2...> MultiArray<T,SRanges...>::format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs)
+    Array<T,SRanges2...> Array<T,SRanges...>::format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs)
     {
 	//MAB::mInit = false;
-	return MultiArray<T,SRanges2...>( nrs , mCont );
+	return Array<T,SRanges2...>( nrs , mCont );
     }
 
     template <typename T, class... SRanges>
     template <class... SRanges2>
-    Slice<T,SRanges2...> MultiArray<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs)
+    Slice<T,SRanges2...> Array<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs)
     {
         return Slice<T,SRanges2...>( nrs..., mCont.data() );
     }
 
     template <typename T, class... SRanges>
     template <class... SRanges2>
-    ConstSlice<T,SRanges2...> MultiArray<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs) const
+    ConstSlice<T,SRanges2...> Array<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs) const
     {
         return ConstSlice<T,SRanges2...>( nrs..., mCont.data() );
     }
     
     template <typename T, class... SRanges>
-    const T* MultiArray<T,SRanges...>::data() const
+    const T* Array<T,SRanges...>::data() const
     {
 	return mCont.data();
     }
 
     template <typename T, class... SRanges>
-    T* MultiArray<T,SRanges...>::data()
+    T* Array<T,SRanges...>::data()
     {
 	return mCont.data();
     }
 
     template <typename T, class... SRanges>
-    std::shared_ptr<MultiArrayBase<T,AnonymousRange> > MultiArray<T,SRanges...>::anonymous(bool slice) const
+    std::shared_ptr<ArrayBase<T,AnonymousRange> > Array<T,SRanges...>::anonymous(bool slice) const
     {
 	AnonymousRangeFactory arf(MAB::mRange->space());
 	if(slice){
@@ -184,14 +184,14 @@ namespace CNORXZ
 		  data() );
 	}
 	else {
-	    return std::make_shared<MultiArray<T,AnonymousRange> >
+	    return std::make_shared<Array<T,AnonymousRange> >
 		( std::dynamic_pointer_cast<AnonymousRange>( arf.create() ),
 		  mCont );
 	}
     }
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator=(const T& in)
+    Array<T,SRanges...>& Array<T,SRanges...>::operator=(const T& in)
     {
 	for(auto& x: mCont){
 	    x = in;
@@ -200,7 +200,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator+=(const MultiArray& in)
+    Array<T,SRanges...>& Array<T,SRanges...>::operator+=(const Array& in)
     {
 	if(not MAB::mInit){ // not initialized by default constructor !!
 	    (*this) = in;
@@ -217,7 +217,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator-=(const MultiArray& in)
+    Array<T,SRanges...>& Array<T,SRanges...>::operator-=(const Array& in)
     {
 	if(not MAB::mInit){ // not initialized by default constructor !!
 	    (*this) = in;
@@ -234,7 +234,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator*=(const T& in)
+    Array<T,SRanges...>& Array<T,SRanges...>::operator*=(const T& in)
     {
 	for(auto& x: mCont){
 	    x *= in;
@@ -243,7 +243,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator/=(const T& in)
+    Array<T,SRanges...>& Array<T,SRanges...>::operator/=(const T& in)
     {
 	for(auto& x: mCont){
 	    x /= in;
@@ -252,7 +252,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::operator T() const
+    Array<T,SRanges...>::operator T() const
     {
 	//static_assert( sizeof...(SRanges) == 1, "try to cast non-scalar type into scalar" );
 	// TODO: check that SIZE is statically = 1 !!!
@@ -260,7 +260,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    auto MultiArray<T,SRanges...>::cat() const
+    auto Array<T,SRanges...>::cat() const
 	-> decltype(ArrayCatter<T>::cat(*this))
     {
 	return ArrayCatter<T>::cat(*this);
diff --git a/src/include/cxz_array.h b/src/include/cxz_array.h
index 97e98ad..7b5471f 100644
--- a/src/include/cxz_array.h
+++ b/src/include/cxz_array.h
@@ -18,49 +18,49 @@ namespace CNORXZ
     struct ArrayCatter
     {
 	template <class... Ranges>
-	static auto cat(const MultiArray<T,Ranges...>& ma)
-	    -> MultiArray<T,Ranges...>
+	static auto cat(const Array<T,Ranges...>& ma)
+	    -> Array<T,Ranges...>
 	{
 	    return ma;
 	}
     };
     
     template <typename T, class... SRanges>
-    class MultiArray : public MutableMultiArrayBase<T,SRanges...>
+    class Array : public MutableArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	
-        using MultiArrayBase<T,SRanges...>::operator[];
-	using MutableMultiArrayBase<T,SRanges...>::operator[];
+        using ArrayBase<T,SRanges...>::operator[];
+	using MutableArrayBase<T,SRanges...>::operator[];
 
-	DEFAULT_MEMBERS(MultiArray);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, const T& val);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec);
+	DEFAULT_MEMBERS(Array);
+	Array(const std::shared_ptr<SRanges>&... ranges);
+	Array(const std::shared_ptr<SRanges>&... ranges, const T& val);
+	Array(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec);
+	Array(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec);
 
         template <class... Ranges>
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, MultiArray<T,Ranges...>&& in); // same effect as format
+	Array(const std::shared_ptr<SRanges>&... ranges, Array<T,Ranges...>&& in); // same effect as format
 
-        MultiArray(const typename CRange::Space& space);
-	MultiArray(const typename CRange::Space& space, const vector<T>& vec);
-	MultiArray(MultiArray<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes);
+        Array(const typename CRange::Space& space);
+	Array(const typename CRange::Space& space, const vector<T>& vec);
+	Array(Array<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes);
 	
 	// Only if ALL ranges have default extensions:
-	//MultiArray(const vector<T>& vec);
-	//MultiArray(vector<T>&& vec);
+	//Array(const vector<T>& vec);
+	//Array(vector<T>&& vec);
 	
 	// template <class Range2, class Range3>
-	// MultiArray(const MultiArray<MultiArray<T,Range2>,Range3> in);
+	// Array(const Array<Array<T,Range2>,Range3> in);
 
-	// implement contstructor using FunctionalMultiArray as Input !!!
+	// implement contstructor using FunctionalArray as Input !!!
 	
 	//template <class Range2, class Range3>
-	//MultiArray& operator=(const MultiArray<MultiArray<T,Range2>,Range3> in);
+	//Array& operator=(const Array<Array<T,Range2>,Range3> in);
 	
 	virtual T& operator[](const IndexType& i) final;
 	virtual const T& operator[](const IndexType& i) const final;
@@ -71,11 +71,11 @@ namespace CNORXZ
 	virtual bool isSlice() const override;
 
 	template <class... SRanges2>
-	MultiArray<T,SRanges2...> format(const std::shared_ptr<SRanges2>&... nrs); // reformat array using 'nr' which in
+	Array<T,SRanges2...> format(const std::shared_ptr<SRanges2>&... nrs); // reformat array using 'nr' which in
 	//                                                                 total must have the same size as mRange
 
 	template <class... SRanges2>
-	MultiArray<T,SRanges2...> format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs);
+	Array<T,SRanges2...> format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs);
 
         template <class... SRanges2>
         Slice<T,SRanges2...> slformat(const std::shared_ptr<SRanges2>&... nrs);
@@ -89,23 +89,23 @@ namespace CNORXZ
 	virtual const vector<T>& vdata() const { return mCont; }
         vector<T>&& vmove() { MAB::mInit = false; return std::move(mCont); }
         
-	virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
-	//virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymousMove() override;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
+	//virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymousMove() override;
 	
 	auto cat() const
 	    -> decltype(ArrayCatter<T>::cat(*this));
 	
 	operator T() const;	
 
-	MultiArray& operator=(const T& in);
+	Array& operator=(const T& in);
 	
-	MultiArray& operator+=(const MultiArray& in);
-	MultiArray& operator-=(const MultiArray& in);
-	MultiArray& operator*=(const T& in);
-	MultiArray& operator/=(const T& in);
+	Array& operator+=(const Array& in);
+	Array& operator-=(const Array& in);
+	Array& operator*=(const T& in);
+	Array& operator/=(const T& in);
 	
 	template <typename U, class... SRanges2>
-	friend class MultiArray;
+	friend class Array;
 	
     private:
 	
@@ -113,17 +113,17 @@ namespace CNORXZ
     };
 
     template <typename T>
-    using Scalar = MultiArray<T,NullRange>;
+    using Scalar = Array<T,NullRange>;
 
     template <typename T>
     Scalar<T> scalar(const T& in);
 
     template <typename T, class... ERanges>
-    struct ArrayCatter<MultiArray<T,ERanges...> >
+    struct ArrayCatter<Array<T,ERanges...> >
     {
 	template <class... Ranges>
-	static auto cat(const MultiArray<MultiArray<T,ERanges...>,Ranges...>& ma)
-	    -> MultiArray<T,Ranges...,ERanges...>
+	static auto cat(const Array<Array<T,ERanges...>,Ranges...>& ma)
+	    -> Array<T,Ranges...,ERanges...>
 	{
 	    auto sma = *ma.begin();
 	    const size_t smas = sma.size();
@@ -136,7 +136,7 @@ namespace CNORXZ
 		assert(x.size() == smas);
 		ov.insert(ov.end(), x.vdata().begin(), x.vdata().end());
 	    }
-	    return MultiArray<T,Ranges...,ERanges...>(cr->space(), std::move(ov));
+	    return Array<T,Ranges...,ERanges...>(cr->space(), std::move(ov));
 	}
     };
 
diff --git a/src/include/cxz_array_base.cc.h b/src/include/cxz_array_base.cc.h
index f24c198..2f5552b 100644
--- a/src/include/cxz_array_base.cc.h
+++ b/src/include/cxz_array_base.cc.h
@@ -5,11 +5,11 @@ namespace CNORXZ
 {
         
     /**********************
-     *  MultiArrayBase    *	     
+     *  ArrayBase    *	     
      **********************/
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>::MultiArrayBase(const MultiArrayBase& in) :
+    ArrayBase<T,SRanges...>::ArrayBase(const ArrayBase& in) :
 	mInit(in.mInit),
 	mRange(in.mRange)
     {
@@ -20,7 +20,7 @@ namespace CNORXZ
 	
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>::MultiArrayBase(MultiArrayBase&& in) :
+    ArrayBase<T,SRanges...>::ArrayBase(ArrayBase&& in) :
 	mInit(in.mInit),
 	mRange(in.mRange)
     {
@@ -30,7 +30,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>& MultiArrayBase<T,SRanges...>::operator=(const MultiArrayBase& in)
+    ArrayBase<T,SRanges...>& ArrayBase<T,SRanges...>::operator=(const ArrayBase& in)
     {
 	mInit = in.mInit;
 	mRange = in.mRange;
@@ -41,7 +41,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>& MultiArrayBase<T,SRanges...>::operator=(MultiArrayBase&& in)
+    ArrayBase<T,SRanges...>& ArrayBase<T,SRanges...>::operator=(ArrayBase&& in)
     {
 	mInit = in.mInit;
 	mRange = in.mRange;
@@ -52,7 +52,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>::MultiArrayBase(const std::shared_ptr<SRanges>&... ranges)
+    ArrayBase<T,SRanges...>::ArrayBase(const std::shared_ptr<SRanges>&... ranges)
     {
 	ContainerRangeFactory<SRanges...> crf(ranges...);
 	mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
@@ -60,7 +60,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>::MultiArrayBase(const typename CRange::Space& space)
+    ArrayBase<T,SRanges...>::ArrayBase(const typename CRange::Space& space)
     {
 	ContainerRangeFactory<SRanges...> crf(space);
 	mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
@@ -69,7 +69,7 @@ namespace CNORXZ
 
     template <typename T, class... SRanges>
     template <typename X>
-    const T& MultiArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
+    const T& ArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
     {
 	IndexType ii(*mProtoI);
 	ii = i;
@@ -77,7 +77,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    const T& MultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const
+    const T& ArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const
     {
 	IndexType ii(*mProtoI);
 	ii(is);
@@ -85,25 +85,25 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    size_t MultiArrayBase<T,SRanges...>::size() const
+    size_t ArrayBase<T,SRanges...>::size() const
     {
 	return mRange->size();
     }
 
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::begin() const
+    typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::begin() const
     {
 	return cbegin();
     }
     
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::end() const
+    typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::end() const
     {
 	return end();
     }
 
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::cbegin() const
+    typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::cbegin() const
     {
 	CIndexType i(*mProtoI,true);
 	i = 0;
@@ -111,7 +111,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::cend() const
+    typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::cend() const
     {
 	CIndexType i(*mProtoI,true);
 	i = i.max();
@@ -119,28 +119,28 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    const std::shared_ptr<typename MultiArrayBase<T,SRanges...>::CRange>&
-    MultiArrayBase<T,SRanges...>::range() const
+    const std::shared_ptr<typename ArrayBase<T,SRanges...>::CRange>&
+    ArrayBase<T,SRanges...>::range() const
     {
 	return mRange;
     }
 
     template <typename T, class... SRanges>
-    bool MultiArrayBase<T,SRanges...>::isConst() const
+    bool ArrayBase<T,SRanges...>::isConst() const
     {
 	return true;
     }
     
     template <typename T, class... SRanges>
     ConstOperationRoot<T,SRanges...>
-    MultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
+    ArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
     {
 	return ConstOperationRoot<T,SRanges...>(*this, inds...);
     }
 
     template <typename T, class... SRanges>
     ConstOperationRoot<T,SRanges...>
-    MultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
+    ArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
     {
 	return ConstOperationRoot<T,SRanges...>(data(), *ind);
     }
@@ -148,7 +148,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     template <class... MappedRanges>
     ConstOperationRoot<T,MappedRanges...>
-    MultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
+    ArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
     {
 	static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
 		      "number of mapped ranges must be equal to number of original ranges");
@@ -156,14 +156,14 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    bool MultiArrayBase<T,SRanges...>::isInit() const
+    bool ArrayBase<T,SRanges...>::isInit() const
     {
 	return mInit;
     }
     
     template <typename T, class... SRanges>
     template <size_t N>
-    auto MultiArrayBase<T,SRanges...>::getRangePtr() const
+    auto ArrayBase<T,SRanges...>::getRangePtr() const
 	-> decltype(mRange->template getPtr<N>())
     {
 	return mRange->template getPtr<N>();
@@ -171,20 +171,20 @@ namespace CNORXZ
 
     
     /******************************
-     *  MutableMultiArrayBase     *	     
+     *  MutableArrayBase     *	     
      ******************************/
 
     template <typename T, class... SRanges>
-    MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges) :
-	MultiArrayBase<T,SRanges...>(ranges...) {}
+    MutableArrayBase<T,SRanges...>::MutableArrayBase(const std::shared_ptr<SRanges>&... ranges) :
+	ArrayBase<T,SRanges...>(ranges...) {}
 
     template <typename T, class... SRanges>
-    MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const typename CRange::Space& space) :
-	MultiArrayBase<T,SRanges...>(space) {}
+    MutableArrayBase<T,SRanges...>::MutableArrayBase(const typename CRange::Space& space) :
+	ArrayBase<T,SRanges...>(space) {}
 
     template <typename T, class... SRanges>
     template <typename X>
-    T& MutableMultiArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
+    T& MutableArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
     {
 	IndexType ii(*MAB::mProtoI);
 	ii = i;
@@ -192,7 +192,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    T& MutableMultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is)
+    T& MutableArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is)
     {
 	IndexType ii(*MAB::mProtoI,this->data());
 	ii(is);
@@ -200,7 +200,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::begin()
+    typename MutableArrayBase<T,SRanges...>::IndexType MutableArrayBase<T,SRanges...>::begin()
     {
 	IndexType i(*MAB::mProtoI,this->data(),true);
 	i = 0;
@@ -208,7 +208,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::end()
+    typename MutableArrayBase<T,SRanges...>::IndexType MutableArrayBase<T,SRanges...>::end()
     {
 	IndexType i(*MAB::mProtoI,this->data(),true);
 	i = i.max();
@@ -217,35 +217,35 @@ namespace CNORXZ
 
     
     template <typename T, class... SRanges>
-    bool MutableMultiArrayBase<T,SRanges...>::isConst() const
+    bool MutableArrayBase<T,SRanges...>::isConst() const
     {
 	return false;
     }
 
     template <typename T, class... SRanges>
     OperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds)
+    MutableArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds)
     {
 	return OperationRoot<T,SRanges...>(*this, inds...);
     }
 
     template <typename T, class... SRanges>
     OperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind)
+    MutableArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind)
     {
 	return OperationRoot<T,SRanges...>(data(), *ind);
     }
     
     template <typename T, class... SRanges>
     ConstOperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
+    MutableArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
     {
 	return ConstOperationRoot<T,SRanges...>(*this, inds...);
     }
 
     template <typename T, class... SRanges>
     ConstOperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
+    MutableArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
     {
 	return ConstOperationRoot<T,SRanges...>(data(), *ind);
     }
@@ -253,7 +253,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     template <class... MappedRanges>
     OperationRoot<T,MappedRanges...>
-    MutableMultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds)
+    MutableArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds)
     {
 	static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
 		      "number of mapped ranges must be equal to number of original ranges");
@@ -263,7 +263,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     template <class... MappedRanges>
     ConstOperationRoot<T,MappedRanges...>
-    MutableMultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
+    MutableArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
     {
 	static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
 		      "number of mapped ranges must be equal to number of original ranges");
diff --git a/src/include/cxz_array_base.h b/src/include/cxz_array_base.h
index 791215e..4e91609 100644
--- a/src/include/cxz_array_base.h
+++ b/src/include/cxz_array_base.h
@@ -51,7 +51,7 @@ namespace CNORXZ
 
     // Explicitely specify subranges in template argument !!!
     template <typename T, class... SRanges>
-    class MultiArrayBase
+    class ArrayBase
     {
     public:
 
@@ -67,17 +67,17 @@ namespace CNORXZ
 
     public:
 
-	//DEFAULT_MEMBERS(MultiArrayBase);
-	MultiArrayBase(const std::shared_ptr<SRanges>&... ranges);
-	MultiArrayBase(const typename CRange::Space& space);
+	//DEFAULT_MEMBERS(ArrayBase);
+	ArrayBase(const std::shared_ptr<SRanges>&... ranges);
+	ArrayBase(const typename CRange::Space& space);
 
-	MultiArrayBase() = default;
-	MultiArrayBase(const MultiArrayBase& in);
-	MultiArrayBase(MultiArrayBase&& in);
-	MultiArrayBase& operator=(const MultiArrayBase& in);
-	MultiArrayBase& operator=(MultiArrayBase&& in);
+	ArrayBase() = default;
+	ArrayBase(const ArrayBase& in);
+	ArrayBase(ArrayBase&& in);
+	ArrayBase& operator=(const ArrayBase& in);
+	ArrayBase& operator=(ArrayBase&& in);
 	
-	virtual ~MultiArrayBase() = default;
+	virtual ~ArrayBase() = default;
 
 	template <typename X>
 	const T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
@@ -100,7 +100,7 @@ namespace CNORXZ
 
 	virtual bool isConst() const;
 
-	virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const = 0;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const = 0;
 
 	virtual ConstOperationRoot<T,SRanges...>
 	op(const std::shared_ptr<CIndexType>& ind) const;
@@ -121,26 +121,26 @@ namespace CNORXZ
     };
 
     template <typename T, class... SRanges>
-    class MutableMultiArrayBase : public MultiArrayBase<T,SRanges...>
+    class MutableArrayBase : public ArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> CIndexType;
 	
-	using MultiArrayBase<T,SRanges...>::operator[];
-	using MultiArrayBase<T,SRanges...>::at;
-	using MultiArrayBase<T,SRanges...>::data;
-	using MultiArrayBase<T,SRanges...>::begin;
-	using MultiArrayBase<T,SRanges...>::end;
-	using MultiArrayBase<T,SRanges...>::cbegin;
-	using MultiArrayBase<T,SRanges...>::cend;
+	using ArrayBase<T,SRanges...>::operator[];
+	using ArrayBase<T,SRanges...>::at;
+	using ArrayBase<T,SRanges...>::data;
+	using ArrayBase<T,SRanges...>::begin;
+	using ArrayBase<T,SRanges...>::end;
+	using ArrayBase<T,SRanges...>::cbegin;
+	using ArrayBase<T,SRanges...>::cend;
 	
-	DEFAULT_MEMBERS(MutableMultiArrayBase);
-	MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges);
-	MutableMultiArrayBase(const typename CRange::Space& space);
+	DEFAULT_MEMBERS(MutableArrayBase);
+	MutableArrayBase(const std::shared_ptr<SRanges>&... ranges);
+	MutableArrayBase(const typename CRange::Space& space);
 
 	template <typename X>
 	T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
diff --git a/src/include/ma_assert.h b/src/include/cxz_assert.h
similarity index 100%
rename from src/include/ma_assert.h
rename to src/include/cxz_assert.h
diff --git a/src/include/cxz_operation.cc.h b/src/include/cxz_operation.cc.h
index 3d12cae..7d50b1b 100644
--- a/src/include/cxz_operation.cc.h
+++ b/src/include/cxz_operation.cc.h
@@ -68,7 +68,7 @@ namespace CNORXZ
     template <class... Indices>
     auto OperationBase<T,OperationClass>::p(const std::shared_ptr<Indices>&... inds) const
     {
-	auto ma = std::make_shared<MultiArray<T,typename Indices::RangeType...>>
+	auto ma = std::make_shared<Array<T,typename Indices::RangeType...>>
 	    (inds->range()... , static_cast<T>(0));
 	(*ma)(inds...) = THIS();
 	return ConstOperationRoot<T,typename Indices::RangeType...>(ma, inds...);
@@ -78,7 +78,7 @@ namespace CNORXZ
     template <class... Indices>
     auto OperationBase<T,OperationClass>::to(const std::shared_ptr<Indices>&... inds) const
     {
-	MultiArray<T,typename Indices::RangeType...> out(inds->range()...);
+	Array<T,typename Indices::RangeType...> out(inds->range()...);
 	out(inds...) = THIS();
 	return out;
     }
@@ -87,7 +87,7 @@ namespace CNORXZ
     template <class... Indices>
     auto OperationBase<T,OperationClass>::addto(const std::shared_ptr<Indices>&... inds) const
     {
-	MultiArray<T,typename Indices::RangeType...> out(inds->range()...,
+	Array<T,typename Indices::RangeType...> out(inds->range()...,
                                                          static_cast<T>(0));
         out(inds...) += THIS();
 	return out;
@@ -97,7 +97,7 @@ namespace CNORXZ
     template <class... Indices>
     auto OperationBase<T,OperationClass>::pto(const std::shared_ptr<Indices>&... inds) const
     {
-	MultiArray<T,typename Indices::RangeType...> out(inds->range()...);
+	Array<T,typename Indices::RangeType...> out(inds->range()...);
 	out(inds...).par() = THIS();
 	return out;
     }
@@ -106,7 +106,7 @@ namespace CNORXZ
     template <class... Indices>
     auto OperationBase<T,OperationClass>::paddto(const std::shared_ptr<Indices>&... inds) const
     {
-	MultiArray<T,typename Indices::RangeType...> out(inds->range()...,
+	Array<T,typename Indices::RangeType...> out(inds->range()...,
                                                          static_cast<T>(0));
         out(inds...).par() += THIS();
 	return out;
@@ -343,7 +343,7 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     ConstOperationRoot<T,Ranges...>::
-    ConstOperationRoot(const MultiArrayBase<T,Ranges...>& ma,
+    ConstOperationRoot(const ArrayBase<T,Ranges...>& ma,
 		       const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
@@ -355,7 +355,7 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     ConstOperationRoot<T,Ranges...>::
-    ConstOperationRoot(std::shared_ptr<MultiArrayBase<T,Ranges...> > maptr,
+    ConstOperationRoot(std::shared_ptr<ArrayBase<T,Ranges...> > maptr,
 		       const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(maptr->data()),
         mOrigDataPtr(maptr->data()),
@@ -517,7 +517,7 @@ namespace CNORXZ
     
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
-    OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+    OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
@@ -531,7 +531,7 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
-    OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+    OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		  const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
@@ -728,7 +728,7 @@ namespace CNORXZ
     
     template <typename T, class... Ranges>
     ParallelOperationRoot<T,Ranges...>::
-    ParallelOperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+    ParallelOperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
diff --git a/src/include/cxz_operation.h b/src/include/cxz_operation.h
index 6299e35..474f529 100644
--- a/src/include/cxz_operation.h
+++ b/src/include/cxz_operation.h
@@ -477,10 +477,10 @@ namespace CNORXZ
         static constexpr bool CONT = true;
         static constexpr bool VABLE = true;
 	
-	ConstOperationRoot(const MultiArrayBase<T,Ranges...>& ma,
+	ConstOperationRoot(const ArrayBase<T,Ranges...>& ma,
 			   const std::shared_ptr<typename Ranges::IndexType>&... indices);
 
-	ConstOperationRoot(std::shared_ptr<MultiArrayBase<T,Ranges...> > maptr,
+	ConstOperationRoot(std::shared_ptr<ArrayBase<T,Ranges...> > maptr,
 			   const std::shared_ptr<typename Ranges::IndexType>&... indices);
 
 	ConstOperationRoot(const T* data, const IndexType& ind);
@@ -506,7 +506,7 @@ namespace CNORXZ
 	const T* mDataPtr;
         const T* mOrigDataPtr;
 	IndexType mIndex;
-	std::shared_ptr<MultiArrayBase<T,Ranges...> > mMaPtr; // never remove this ptr, otherwise we lose temporary container instances!
+	std::shared_ptr<ArrayBase<T,Ranges...> > mMaPtr; // never remove this ptr, otherwise we lose temporary container instances!
     };
 
     template <typename T, class Op>
@@ -609,10 +609,10 @@ namespace CNORXZ
 	IndexType mIndex;
 
     public:
-	OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+	OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		      const std::shared_ptr<typename Ranges::IndexType>&... indices);
 
-	OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+	OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		      const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices);
 
 	OperationRoot(T* data, const IndexType& ind);
@@ -695,7 +695,7 @@ namespace CNORXZ
 	IndexType mIndex;
 
     public:
-	ParallelOperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+	ParallelOperationRoot(MutableArrayBase<T,Ranges...>& ma,
                               const std::shared_ptr<typename Ranges::IndexType>&... indices);
 
 	ParallelOperationRoot(T* data, const IndexType& ind);
diff --git a/src/include/dynamic_operation.cc.h b/src/include/dynamic_operation.cc.h
index c0f02fe..43bbb45 100644
--- a/src/include/dynamic_operation.cc.h
+++ b/src/include/dynamic_operation.cc.h
@@ -45,7 +45,7 @@ namespace CNORXZ
     DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const DynamicOuterOp& in) :
 	mThreadId(omp_get_thread_num()), mOp(in.mOp),
 	mIndices(in.mIndices),
-	mMa((mThreadId != in.mThreadId) ? std::make_shared<MultiArray<T,Ranges...>>(*in.mMa) : in.mMa),
+	mMa((mThreadId != in.mThreadId) ? std::make_shared<Array<T,Ranges...>>(*in.mMa) : in.mMa),
 	mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto),
 	mL((mThreadId != in.mThreadId) ?
 	   mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
@@ -60,7 +60,7 @@ namespace CNORXZ
     DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(DynamicOuterOp&& in) :
 	mThreadId(omp_get_thread_num()), mOp(in.mOp),
 	mIndices(in.mIndices),
-	mMa((mThreadId != in.mThreadId) ? std::make_shared<MultiArray<T,Ranges...>>(*in.mMa) : in.mMa),
+	mMa((mThreadId != in.mThreadId) ? std::make_shared<Array<T,Ranges...>>(*in.mMa) : in.mMa),
 	mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto),
 	mL((mThreadId != in.mThreadId) ?
 	   mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
@@ -79,7 +79,7 @@ namespace CNORXZ
 	mOp = in.mOp;
 	mIndices = in.mIndices;
 	if(mThreadId != in.mThreadId){
-	    mMa = std::make_shared<MultiArray<T,Ranges...>>(in.mMa);
+	    mMa = std::make_shared<Array<T,Ranges...>>(in.mMa);
 	    mProto = OperationRoot<T,Ranges...>(*mMa,mIndices);
 	    mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
 			 std::make_tuple(mMa),
@@ -103,7 +103,7 @@ namespace CNORXZ
 	mOp = in.mOp;
 	mIndices = in.mIndices;
 	if(mThreadId != in.mThreadId){
-	    mMa = std::make_shared<MultiArray<T,Ranges...>>(in.mMa);
+	    mMa = std::make_shared<Array<T,Ranges...>>(in.mMa);
 	    mProto = OperationRoot<T,Ranges...>(*mMa,mIndices);
 	    mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
 			 std::make_tuple(mMa),
@@ -124,7 +124,7 @@ namespace CNORXZ
                                                           const std::shared_ptr<typename Ranges::IndexType>&... inds)
         : mThreadId(omp_get_thread_num()), mOp(op),
 	  mIndices(inds...),
-	  mMa(std::make_shared<MultiArray<T,Ranges...>>(mkArray<T>(inds->range()...))),
+	  mMa(std::make_shared<Array<T,Ranges...>>(mkArray<T>(inds->range()...))),
 	  mProto(OperationRoot<T,Ranges...>(*mMa,inds...)),
           mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
              std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),
@@ -137,7 +137,7 @@ namespace CNORXZ
 	: mThreadId(omp_get_thread_num()),
 	  //mDyn(dyn),
 	  mOp(op), mIndices(inds...),
-	  mMa(std::make_shared<MultiArray<T,Ranges...>>(mkArray<T>(inds->range()...))),
+	  mMa(std::make_shared<Array<T,Ranges...>>(mkArray<T>(inds->range()...))),
 	  mProto(OperationRoot<T,Ranges...>(*mMa,inds...)),
           mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
              std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),
diff --git a/src/include/dynamic_operation.h b/src/include/dynamic_operation.h
index 08fed92..a2973fe 100644
--- a/src/include/dynamic_operation.h
+++ b/src/include/dynamic_operation.h
@@ -1,6 +1,6 @@
 
-#ifndef __dynamic_operation_h__
-#define __dynamic_operation_h__
+#ifndef __cxz_dynamic_operation_h__
+#define __cxz_dynamic_operation_h__
 
 #include "base_def.h"
 #include "cxz_operation.h"
@@ -77,13 +77,13 @@ namespace CNORXZ
 	Operation mOp;
         //OperationRoot<T,Ranges...> mProto;
 	std::tuple<std::shared_ptr<typename Ranges::IndexType>...> mIndices;
-	std::shared_ptr<MultiArray<T,Ranges...>> mMa;
+	std::shared_ptr<Array<T,Ranges...>> mMa;
         OpH<OperationRoot<T,Ranges...>> mProto;
 
 	
 	typedef ILoop<std::tuple<OperationRoot<T,Ranges...>,Operation>,
 		      std::tuple<std::shared_ptr<typename Ranges::IndexType>...>,
-		      std::tuple<std::shared_ptr<MultiArray<T,Ranges...>>>,
+		      std::tuple<std::shared_ptr<Array<T,Ranges...>>>,
             std::tuple<decltype(mProto.mOp->assign( mOp, mkMIndex(std::shared_ptr<typename Ranges::IndexType>()...) ))>> LoopT;
 	
 	
diff --git a/src/include/functional_array.cc.h b/src/include/functional_array.cc.h
index 02fb54e..01520cd 100644
--- a/src/include/functional_array.cc.h
+++ b/src/include/functional_array.cc.h
@@ -6,30 +6,30 @@ namespace CNORXZ
 
 
     /****************************
-     *   FunctionalMultiArray   *	     
+     *   FunctionalArray   *	     
      ****************************/
 
     template <typename T, class Function, class... SRanges>
-    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges,
+    FunctionalArray<T,Function,SRanges...>::FunctionalArray(const std::shared_ptr<SRanges>&... ranges,
 								      const std::shared_ptr<Function>& func) :
-	MultiArrayBase<T,SRanges...>(ranges...), mFunc(func) {}
+	ArrayBase<T,SRanges...>(ranges...), mFunc(func) {}
 
     template <typename T, class Function, class... SRanges>
-    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges) :
-	MultiArrayBase<T,SRanges...>(ranges...) {}
+    FunctionalArray<T,Function,SRanges...>::FunctionalArray(const std::shared_ptr<SRanges>&... ranges) :
+	ArrayBase<T,SRanges...>(ranges...) {}
 
     template <typename T, class Function, class... SRanges>
-    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space) :
-	MultiArrayBase<T,SRanges...>(space) {}
+    FunctionalArray<T,Function,SRanges...>::FunctionalArray(const typename CRange::Space& space) :
+	ArrayBase<T,SRanges...>(space) {}
 
     template <typename T, class Function, class... SRanges>
-    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space,
+    FunctionalArray<T,Function,SRanges...>::FunctionalArray(const typename CRange::Space& space,
 								      const std::shared_ptr<Function>& func) :
-	MultiArrayBase<T,SRanges...>(space), mFunc(func) {}
+	ArrayBase<T,SRanges...>(space), mFunc(func) {}
 
     
     template <typename T, class Function, class... SRanges>
-    const T& FunctionalMultiArray<T,Function,SRanges...>::operator[](const IndexType& i) const
+    const T& FunctionalArray<T,Function,SRanges...>::operator[](const IndexType& i) const
     {
 	if constexpr(Function::FISSTATIC){
 	    mVal = Function::apply(i.meta());
@@ -41,7 +41,7 @@ namespace CNORXZ
     }
 
     template <typename T, class Function, class... SRanges>
-    const T& FunctionalMultiArray<T,Function,SRanges...>::at(const typename CRange::IndexType::MetaType& meta) const
+    const T& FunctionalArray<T,Function,SRanges...>::at(const typename CRange::IndexType::MetaType& meta) const
     {
 	if constexpr(Function::FISSTATIC){
 	    mVal = Function::apply(meta);
@@ -53,32 +53,32 @@ namespace CNORXZ
     }
 
     template <typename T, class Function, class... SRanges>
-    const T* FunctionalMultiArray<T,Function,SRanges...>::data() const
+    const T* FunctionalArray<T,Function,SRanges...>::data() const
     {
 	return &mVal;
     }
     
     template <typename T, class Function, class... SRanges>
-    bool FunctionalMultiArray<T,Function,SRanges...>::isConst() const
+    bool FunctionalArray<T,Function,SRanges...>::isConst() const
     {
 	return true;
     }
 
     template <typename T, class Function, class... SRanges>
-    bool FunctionalMultiArray<T,Function,SRanges...>::isSlice() const
+    bool FunctionalArray<T,Function,SRanges...>::isSlice() const
     {
 	return false;
     }
 
     template <typename T, class Function, class... SRanges>
-    std::shared_ptr<MultiArrayBase<T,AnonymousRange> > FunctionalMultiArray<T,Function,SRanges...>::anonymous(bool slice) const
+    std::shared_ptr<ArrayBase<T,AnonymousRange> > FunctionalArray<T,Function,SRanges...>::anonymous(bool slice) const
     {
 	assert(0); // think about it carefully
 	return nullptr;
     }
 	
     template <typename T, class Function, class... SRanges>
-    ConstOperationRoot<T,SRanges...> FunctionalMultiArray<T,Function,SRanges...>::
+    ConstOperationRoot<T,SRanges...> FunctionalArray<T,Function,SRanges...>::
     operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
     {
 	if(not mMaPtr){
@@ -89,7 +89,7 @@ namespace CNORXZ
     }
 
     template <typename T, class Function, class... SRanges>
-    auto FunctionalMultiArray<T,Function,SRanges...>::
+    auto FunctionalArray<T,Function,SRanges...>::
     exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
 	-> Operation<T,Function,MetaOperationRoot<SRanges>...>
     {
diff --git a/src/include/functional_array.h b/src/include/functional_array.h
index 10112dc..b8df149 100644
--- a/src/include/functional_array.h
+++ b/src/include/functional_array.h
@@ -1,6 +1,6 @@
 
-#ifndef __functional_array__
-#define __functional_array__
+#ifndef __cxz_functional_array__
+#define __cxz_functional_array__
 
 #include "cxz_array_base.h"
 #include "slice.h"
@@ -9,14 +9,14 @@ namespace CNORXZ
 {
     
     template <typename T, class Function, class... SRanges>
-    class FunctionalMultiArray : public MultiArrayBase<T,SRanges...>
+    class FunctionalArray : public ArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
-	typedef MultiArray<T,SRanges...> MAType;
+	typedef Array<T,SRanges...> MAType;
 	typedef T value_type;
 	
     private:
@@ -27,11 +27,11 @@ namespace CNORXZ
 
     public:
 	
-	DEFAULT_MEMBERS(FunctionalMultiArray);
-	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges, const std::shared_ptr<Function>& func);
-	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges);
-	FunctionalMultiArray(const typename CRange::Space& space);
-	FunctionalMultiArray(const typename CRange::Space& space, const std::shared_ptr<Function>& func);
+	DEFAULT_MEMBERS(FunctionalArray);
+	FunctionalArray(const std::shared_ptr<SRanges>&... ranges, const std::shared_ptr<Function>& func);
+	FunctionalArray(const std::shared_ptr<SRanges>&... ranges);
+	FunctionalArray(const typename CRange::Space& space);
+	FunctionalArray(const typename CRange::Space& space, const std::shared_ptr<Function>& func);
 	
 	virtual const T& operator[](const IndexType& i) const override;
 	virtual const T& at(const typename CRange::IndexType::MetaType& meta) const override;
@@ -40,7 +40,7 @@ namespace CNORXZ
 	virtual bool isConst() const override;	
 	virtual bool isSlice() const override;
 
-	virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
 
 	auto exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
             -> Operation<T,Function,MetaOperationRoot<SRanges>...>;
diff --git a/src/include/helper_tools.cc.h b/src/include/helper_tools.cc.h
index 957eb96..c2dfb19 100644
--- a/src/include/helper_tools.cc.h
+++ b/src/include/helper_tools.cc.h
@@ -237,7 +237,7 @@ namespace CNORXZ
 
     template <class MArray>
     auto dynamic(const MArray& ma, bool slice)
-	-> std::shared_ptr<MultiArrayBase<typename MArray::value_type,DynamicRange>>
+	-> std::shared_ptr<ArrayBase<typename MArray::value_type,DynamicRange>>
     {
 	DynamicRangeFactory drf(ma.range()->space());
 	if(slice){
@@ -246,7 +246,7 @@ namespace CNORXZ
 		  ma.data() );
 	}
 	else {
-	    return std::make_shared<MultiArray<typename MArray::value_type,DynamicRange>>
+	    return std::make_shared<Array<typename MArray::value_type,DynamicRange>>
 		( std::dynamic_pointer_cast<DynamicRange>( drf.create() ),
 		  ma.vdata() );
 	}
@@ -254,7 +254,7 @@ namespace CNORXZ
 
     template <class MArray>
     auto mdynamic(MArray& ma, bool slice)
-	-> std::shared_ptr<MutableMultiArrayBase<typename MArray::value_type,DynamicRange>>
+	-> std::shared_ptr<MutableArrayBase<typename MArray::value_type,DynamicRange>>
     {
 	DynamicRangeFactory drf(ma.range()->space());
 	if(slice){
@@ -263,7 +263,7 @@ namespace CNORXZ
 		  ma.data() );
 	}
 	else {
-	    return std::make_shared<MultiArray<typename MArray::value_type,DynamicRange>>
+	    return std::make_shared<Array<typename MArray::value_type,DynamicRange>>
 		( std::dynamic_pointer_cast<DynamicRange>( drf.create() ),
 		  ma.vdata() );
 	}
@@ -294,7 +294,7 @@ namespace CNORXZ
     }
     
     template <typename T, class Range1, class... RangeTypes>
-    auto anonToDynView(const MultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
 	-> ConstSlice<T,Range1,RangeTypes...,DynamicRange>
     {
 	constexpr size_t LAST = sizeof...(RangeTypes)+1;
@@ -307,7 +307,7 @@ namespace CNORXZ
     }
 
     template <typename T, class Range1, class... RangeTypes>
-    auto anonToDynView(MutableMultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
+    auto anonToDynView(MutableArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
 	-> Slice<T,Range1,RangeTypes...,DynamicRange>
     {
 	constexpr size_t LAST = sizeof...(RangeTypes)+1;
@@ -320,8 +320,8 @@ namespace CNORXZ
     }
 
     template <typename T, class Range1, class... RangeTypes>
-    auto dynToAnonMove(MultiArray<T,Range1,RangeTypes...,DynamicRange>&& ma)
-	-> MultiArray<T,Range1,RangeTypes...,AnonymousRange>
+    auto dynToAnonMove(Array<T,Range1,RangeTypes...,DynamicRange>&& ma)
+	-> Array<T,Range1,RangeTypes...,AnonymousRange>
     {
 	constexpr size_t LAST = sizeof...(RangeTypes)+1;
 	AnonymousRangeFactory arf(rptr<LAST>(ma)->orig());
@@ -333,7 +333,7 @@ namespace CNORXZ
     }
 
     template <typename T>
-    auto anonToDynView(const MultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,AnonymousRange>& ma)
 	-> ConstSlice<T,DynamicRange>
     {
 	DynamicRangeFactory drf(rptr<0>(ma)->orig());
@@ -342,7 +342,7 @@ namespace CNORXZ
     }
 
     template <typename T>
-    auto anonToDynView(MutableMultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(MutableArrayBase<T,AnonymousRange>& ma)
 	-> Slice<T,DynamicRange>
     {
 	DynamicRangeFactory drf(rptr<0>(ma)->orig());
@@ -351,8 +351,8 @@ namespace CNORXZ
     }
 
     template <typename T>
-    auto dynToAnonMove(MultiArray<T,DynamicRange>&& ma)
-	-> MultiArray<T,AnonymousRange>
+    auto dynToAnonMove(Array<T,DynamicRange>&& ma)
+	-> Array<T,AnonymousRange>
     {
 	AnonymousRangeFactory arf(rptr<0>(ma)->orig());
 	auto mNSpace = std::make_tuple( createExplicit( arf ) );
@@ -376,23 +376,23 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     auto mkArray(const std::shared_ptr<Ranges>&... rs)
-        -> MultiArray<T,Ranges...>
+        -> Array<T,Ranges...>
     {
-        return MultiArray<T,Ranges...>(rs...);
+        return Array<T,Ranges...>(rs...);
     }
 
     template <typename T, class... Ranges>
     auto mkArray(const std::shared_ptr<Ranges>&... rs, const T& val)
-        -> MultiArray<T,Ranges...>
+        -> Array<T,Ranges...>
     {
-        return MultiArray<T,Ranges...>(rs..., val);
+        return Array<T,Ranges...>(rs..., val);
     }
 
     template <typename T, class... Ranges>
     auto mkArrayPtr(const std::shared_ptr<Ranges>&... rs)
-        -> std::shared_ptr<MultiArray<T,Ranges...>>
+        -> std::shared_ptr<Array<T,Ranges...>>
     {
-	return std::make_shared<MultiArray<T,Ranges...>>(rs...);
+	return std::make_shared<Array<T,Ranges...>>(rs...);
     }
 
 }
diff --git a/src/include/helper_tools.h b/src/include/helper_tools.h
index 71f5788..dc1aab1 100644
--- a/src/include/helper_tools.h
+++ b/src/include/helper_tools.h
@@ -1,6 +1,6 @@
 
-#ifndef __helper_tools_h__
-#define __helper_tools_h__
+#ifndef __cxz_helper_tools_h__
+#define __cxz_helper_tools_h__
 
 #include "base_def.h"
 #include "slice.h"
@@ -119,35 +119,35 @@ namespace CNORXZ
     
     template <class MArray>
     auto dynamic(const MArray& ma, bool slice = false)
-	-> std::shared_ptr<MultiArrayBase<typename MArray::value_type,DynamicRange>>;
+	-> std::shared_ptr<ArrayBase<typename MArray::value_type,DynamicRange>>;
 
     template <class MArray>
     auto mdynamic(MArray& ma, bool slice)
-	-> std::shared_ptr<MutableMultiArrayBase<typename MArray::value_type,DynamicRange>>;
+	-> std::shared_ptr<MutableArrayBase<typename MArray::value_type,DynamicRange>>;
     
     template <typename T, class Range1, class... RangeTypes>
-    auto anonToDynView(const MultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
 	-> ConstSlice<T,Range1,RangeTypes...,DynamicRange>;
 
     template <typename T, class Range1, class... RangeTypes>
-    auto anonToDynView(MutableMultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
+    auto anonToDynView(MutableArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
 	-> Slice<T,Range1,RangeTypes...,DynamicRange>;
 
     template <typename T, class Range1, class... RangeTypes>
-    auto dynToAnonMove(MultiArray<T,Range1,RangeTypes...,DynamicRange>&& ma)
-	-> MultiArray<T,Range1,RangeTypes...,AnonymousRange>;
+    auto dynToAnonMove(Array<T,Range1,RangeTypes...,DynamicRange>&& ma)
+	-> Array<T,Range1,RangeTypes...,AnonymousRange>;
 
     template <typename T>
-    auto anonToDynView(const MultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,AnonymousRange>& ma)
 	-> ConstSlice<T,DynamicRange>;
 
     template <typename T>
-    auto anonToDynView(MutableMultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(MutableArrayBase<T,AnonymousRange>& ma)
 	-> Slice<T,DynamicRange>;
 
     template <typename T>
-    auto dynToAnonMove(MultiArray<T,DynamicRange>&& ma)
-	-> MultiArray<T,AnonymousRange>;
+    auto dynToAnonMove(Array<T,DynamicRange>&& ma)
+	-> Array<T,AnonymousRange>;
 
     template <class Range>
     auto metaSlice(const std::shared_ptr<Range>& r)
@@ -159,15 +159,15 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     auto mkArray(const std::shared_ptr<Ranges>&... rs)
-        -> MultiArray<T,Ranges...>;
+        -> Array<T,Ranges...>;
 
     template <typename T, class... Ranges>
     auto mkArrayPtr(const std::shared_ptr<Ranges>&... rs)
-        -> std::shared_ptr<MultiArray<T,Ranges...>>;
+        -> std::shared_ptr<Array<T,Ranges...>>;
 
     template <typename T, class... Ranges>
     auto mkArray(const std::shared_ptr<Ranges>&... rs, const T& val)
-        -> MultiArray<T,Ranges...>;
+        -> Array<T,Ranges...>;
 
     template <class OpTp, class IndTp, class VarTp, class LTp>
     auto mkILoop(const OpTp& opTp, const IndTp& indTp, const VarTp& varTp, const LTp& lTp,
@@ -214,11 +214,11 @@ namespace CNORXZ
 
     template <class Index>
     inline auto mkOp(const std::shared_ptr<Index>& i)
-	-> decltype(std::declval<FunctionalMultiArray<typename Index::MetaType,
+	-> decltype(std::declval<FunctionalArray<typename Index::MetaType,
 		    identity<typename Index::MetaType>,typename Index::RangeType> >
 		    ().exec(i))
     {
-	FunctionalMultiArray<typename Index::MetaType,
+	FunctionalArray<typename Index::MetaType,
 			     identity<typename Index::MetaType>,
 			     typename Index::RangeType> fma(i->range());
 	return fma.exec(i);
diff --git a/src/include/high_level_operation.h b/src/include/high_level_operation.h
index 71706fa..b2fafa8 100644
--- a/src/include/high_level_operation.h
+++ b/src/include/high_level_operation.h
@@ -1,6 +1,6 @@
 
-#ifndef __high_level_operation_h__
-#define __high_level_operation_h__
+#ifndef __cxz_high_level_operation_h__
+#define __cxz_high_level_operation_h__
 
 #include "base_def.h"
 #include "ranges/rheader.h"
diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 8cc780e..d9c0cd5 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -415,7 +415,7 @@ namespace CNORXZ
     struct OutRangeMaker<SpaceType::ANY>
     {
         template <class MapF, class ORType>
-        static void mk(std::shared_ptr<ORType>& outRange, MultiArray<size_t,ORType>& mapMult, const MapF& mapf)
+        static void mk(std::shared_ptr<ORType>& outRange, Array<size_t,ORType>& mapMult, const MapF& mapf)
         {
             std::map<typename MapF::value_type,size_t> mult;
             for(auto ii = mapf.begin(); ii.max() != ii.pos(); ++ii) {
@@ -434,7 +434,7 @@ namespace CNORXZ
 
             typename ORType::FType orf(outmeta);
             outRange = std::dynamic_pointer_cast<ORType>( orf.create() );
-            mapMult = MultiArray<size_t,ORType>( outRange, outmult );
+            mapMult = Array<size_t,ORType>( outRange, outmult );
         }
     };
 
@@ -442,7 +442,7 @@ namespace CNORXZ
     struct OutRangeMaker<SpaceType::NONE>
     {
         template <class MapF, class ORType>
-        static void mk(std::shared_ptr<ORType>& outRange, MultiArray<size_t,ORType>& mapMult, const MapF& mapf)
+        static void mk(std::shared_ptr<ORType>& outRange, Array<size_t,ORType>& mapMult, const MapF& mapf)
         {
             static_assert( std::is_same<size_t,typename MapF::value_type>::value,
                            "out range value type for NONE must be size_t" );
@@ -464,7 +464,7 @@ namespace CNORXZ
 
             typename ORType::FType orf(max);
             outRange = std::dynamic_pointer_cast<ORType>( orf.create() );
-            mapMult = MultiArray<size_t,ORType>( outRange, outmult );
+            mapMult = Array<size_t,ORType>( outRange, outmult );
         }
     };
 
@@ -472,7 +472,7 @@ namespace CNORXZ
     template <class MA>
     void GenMapRange<ORType,Op,XSTYPE,Ranges...>::mkOutRange(const MA& mapf)
     {
-	//FunctionalMultiArray<typename MapF::value_type,MapF,Ranges...> fma(mSpace, mMapf);
+	//FunctionalArray<typename MapF::value_type,MapF,Ranges...> fma(mSpace, mMapf);
         OutRangeMaker<XSTYPE>::mk(mOutRange,mMapMult,mapf);
         auto i = mapf.begin();
         mMapPos.resize(i.max());
@@ -666,7 +666,7 @@ namespace CNORXZ
 
     template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
     auto GenMapRange<ORType,Op,XSTYPE,Ranges...>::mapMultiplicity() const
-	-> const MultiArray<size_t,ORType>&
+	-> const Array<size_t,ORType>&
     {
 	return mMapMult;
     }
diff --git a/src/include/map_range.h b/src/include/map_range.h
index 9532f2b..024a7f5 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __map_range_h__
-#define __map_range_h__
+#ifndef __cxz_map_range_h__
+#define __cxz_map_range_h__
 
 #include <cstdlib>
 #include <tuple>
@@ -29,12 +29,12 @@ namespace CNORXZ
     template <class Func, class... Indices>
     auto mkMapOp(const std::shared_ptr<Func>& func,
 		 const std::shared_ptr<Indices>&... is)
-	-> decltype(std::make_tuple(FunctionalMultiArray<typename Func::value_type,Func,
+	-> decltype(std::make_tuple(FunctionalArray<typename Func::value_type,Func,
                                     typename Indices::RangeType...>().exec(is...),
-                                    FunctionalMultiArray<typename Func::value_type,Func,
+                                    FunctionalArray<typename Func::value_type,Func,
                                     typename Indices::RangeType...>()))
     {
-        typedef FunctionalMultiArray<typename Func::value_type,Func,typename Indices::RangeType...> FMA;
+        typedef FunctionalArray<typename Func::value_type,Func,typename Indices::RangeType...> FMA;
         if(Func::FISSTATIC){
             FMA fma(is->range()...);
             return std::make_tuple(fma.exec(is...),fma);
@@ -277,7 +277,7 @@ namespace CNORXZ
         Op mMapf;
 	//Op mMapf;
 	std::shared_ptr<ORType> mOutRange;
-	MultiArray<size_t,ORType> mMapMult;
+	Array<size_t,ORType> mMapMult;
         vector<size_t> mMapPos;
         
     private:
@@ -314,7 +314,7 @@ namespace CNORXZ
 	virtual IndexType begin() const final;
 	virtual IndexType end() const final;
 
-	const MultiArray<size_t,ORType>& mapMultiplicity() const;
+	const Array<size_t,ORType>& mapMultiplicity() const;
 	ConstSlice<size_t,GenMapRange> explMapMultiplicity() const;
 
         vector<size_t> mapPos() const;
diff --git a/src/include/map_range_factory_product_map.h b/src/include/map_range_factory_product_map.h
index cc89ed2..8406e07 100644
--- a/src/include/map_range_factory_product_map.h
+++ b/src/include/map_range_factory_product_map.h
@@ -1,6 +1,6 @@
 
-#ifndef __map_range_factory_product_map_h__
-#define __map_range_factory_product_map_h__
+#ifndef __cxz_map_range_factory_product_map_h__
+#define __cxz_map_range_factory_product_map_h__
 
 #include <memory>
 #include <vector>
diff --git a/src/include/mbase_def.h b/src/include/mbase_def.h
index 39eb5a4..16b07cd 100644
--- a/src/include/mbase_def.h
+++ b/src/include/mbase_def.h
@@ -1,6 +1,6 @@
 
-#ifndef __mbase_def_h__
-#define __mbase_def_h__
+#ifndef __cxz_mbase_def_h__
+#define __cxz_mbase_def_h__
 
 #include "ranges/rbase_def.h"
 #include "allocator.h"
@@ -23,15 +23,15 @@ namespace CNORXZ
 
     // cxz_array.h
     template <typename T, class... SRanges>
-    class MultiArrayBase;
+    class ArrayBase;
 
     // cxz_array.h
     template <typename T, class... SRanges>
-    class MutableMultiArrayBase;
+    class MutableArrayBase;
     
     // cxz_array.h
     template <typename T, class... SRanges>
-    class MultiArray;
+    class Array;
    
     // cxz_operation.h
     template <typename T, class OperationClass>
diff --git a/src/include/operation_def.h b/src/include/operation_def.h
index 287970c..7dcb685 100644
--- a/src/include/operation_def.h
+++ b/src/include/operation_def.h
@@ -1,6 +1,6 @@
 
-#ifndef __operation_def_h__
-#define __operation_def_h__
+#ifndef __cxz_operation_def_h__
+#define __cxz_operation_def_h__
 
 #include "cxz_operation.h"
 
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index 031d0c0..643a159 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/src/include/ranges/anonymous_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __anonymous_range_h__
-#define __anonymous_range_h__
+#ifndef __cxz_anonymous_range_h__
+#define __cxz_anonymous_range_h__
 
 #include <cstdlib>
 #include <map>
diff --git a/src/include/ranges/dynamic_meta.h b/src/include/ranges/dynamic_meta.h
index 51535aa..a1a4d60 100644
--- a/src/include/ranges/dynamic_meta.h
+++ b/src/include/ranges/dynamic_meta.h
@@ -1,6 +1,6 @@
 
-#ifndef __dynamic_meta_h__
-#define __dynamic_meta_h__
+#ifndef __cxz_dynamic_meta_h__
+#define __cxz_dynamic_meta_h__
 
 #include <cstdlib>
 #include <utility>
diff --git a/src/include/ranges/dynamic_range.h b/src/include/ranges/dynamic_range.h
index f0075c6..e69f487 100644
--- a/src/include/ranges/dynamic_range.h
+++ b/src/include/ranges/dynamic_range.h
@@ -1,6 +1,6 @@
 
-#ifndef __dynamic_range_h__
-#define __dynamic_range_h__
+#ifndef __cxz_dynamic_range_h__
+#define __cxz_dynamic_range_h__
 
 #include <cassert>
 #include <map>
diff --git a/src/include/ranges/index_base.h b/src/include/ranges/index_base.h
index 9c0c4b2..627a907 100644
--- a/src/include/ranges/index_base.h
+++ b/src/include/ranges/index_base.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __index_base_h__
-#define __index_base_h__
+#ifndef __cxz_index_base_h__
+#define __cxz_index_base_h__
 
 #include <cstdlib>
 #include <string>
diff --git a/src/include/ranges/index_type.h b/src/include/ranges/index_type.h
index ac5e0fd..c57938f 100644
--- a/src/include/ranges/index_type.h
+++ b/src/include/ranges/index_type.h
@@ -1,6 +1,6 @@
 
-#ifndef __index_type_h__
-#define __index_type_h__
+#ifndef __cxz_index_type_h__
+#define __cxz_index_type_h__
 
 namespace CNORXZ
 {
diff --git a/src/include/ranges/index_wrapper.h b/src/include/ranges/index_wrapper.h
index 580412e..28efcf6 100644
--- a/src/include/ranges/index_wrapper.h
+++ b/src/include/ranges/index_wrapper.h
@@ -1,6 +1,6 @@
 
-#ifndef __index_wrapper_h__
-#define __index_wrapper_h__
+#ifndef __cxz_index_wrapper_h__
+#define __cxz_index_wrapper_h__
 
 #include "ranges/rbase_def.h"
 #include "xfor/xfor.h"
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 3ab22d6..6efda26 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __multi_range_h__
-#define __multi_range_h__
+#ifndef __cxz_multi_range_h__
+#define __cxz_multi_range_h__
 
 #include <cstdlib>
 #include <tuple>
diff --git a/src/include/ranges/multi_range_factory_product_map.h b/src/include/ranges/multi_range_factory_product_map.h
index 6630b1d..adba8ce 100644
--- a/src/include/ranges/multi_range_factory_product_map.h
+++ b/src/include/ranges/multi_range_factory_product_map.h
@@ -1,6 +1,6 @@
 
-#ifndef __multi_range_factory_product_map_h__
-#define __multi_range_factory_product_map_h__
+#ifndef __cxz_multi_range_factory_product_map_h__
+#define __cxz_multi_range_factory_product_map_h__
 
 #include <memory>
 #include <vector>
diff --git a/src/include/ranges/range_base.h b/src/include/ranges/range_base.h
index a701e3d..548d3da 100644
--- a/src/include/ranges/range_base.h
+++ b/src/include/ranges/range_base.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __range_base_h__
-#define __range_base_h__
+#ifndef __cxz_range_base_h__
+#define __cxz_range_base_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 53f1462..d60f78a 100644
--- a/src/include/ranges/range_helper.h
+++ b/src/include/ranges/range_helper.h
@@ -1,6 +1,6 @@
 
-#ifndef __range_helper_h__
-#define __range_helper_h__
+#ifndef __cxz_range_helper_h__
+#define __cxz_range_helper_h__
 
 namespace CNORXZ
 {
diff --git a/src/include/ranges/range_types/classic_range.h b/src/include/ranges/range_types/classic_range.h
index 492d66a..dccd37e 100644
--- a/src/include/ranges/range_types/classic_range.h
+++ b/src/include/ranges/range_types/classic_range.h
@@ -4,11 +4,11 @@
 //#else
 
 #ifndef include_range_type
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 // assert, that this is only used within range_types/header.h
 
-#ifndef __range_type_classic_def__
-#define __range_type_classic_def__
+#ifndef __cxz_range_type_classic_def__
+#define __cxz_range_type_classic_def__
 
 namespace CNORXZ
 {
@@ -80,8 +80,8 @@ namespace CNORXZ
 }
 
 
-#endif // #ifndef __range_type_classic_def__
+#endif // #ifndef __cxz_range_type_classic_def__
 
-#endif // #ifdef __ranges_header__
+#endif // #ifdef __cxz_ranges_header__
 
 #endif // #ifdef include_range_type
diff --git a/src/include/ranges/range_types/header.h b/src/include/ranges/range_types/header.h
index 6fef0a9..2026d20 100644
--- a/src/include/ranges/range_types/header.h
+++ b/src/include/ranges/range_types/header.h
@@ -1,19 +1,19 @@
 
 #ifdef include_range_type
-#define __incl_this__
+#define __cxz_incl_this__
 #endif
-#ifdef __single_range_h__
+#ifdef __cxz_single_range_h__
 // singel_range is template which is specialized here
 // therefore it must be defined before...
-#define __incl_this__
+#define __cxz_incl_this__
 #endif
 
-#ifdef __incl_this__
+#ifdef __cxz_incl_this__
 
 
-#define __ranges_header__
-//#ifndef __ranges_header__
-//#define __ranges_header__
+#define __cxz_ranges_header__
+//#ifndef __cxz_ranges_header__
+//#define __cxz_ranges_header__
 
 #include "null_range.h"
 #include "spin_range.h"
diff --git a/src/include/ranges/range_types/null_range.h b/src/include/ranges/range_types/null_range.h
index b87e39e..810ce30 100644
--- a/src/include/ranges/range_types/null_range.h
+++ b/src/include/ranges/range_types/null_range.h
@@ -4,11 +4,11 @@
 include_range_type(NUL,-2)
 #else
 
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 // assert, that this is only used within range_types/header.h
 
-#ifndef __range_type_null_def__
-#define __range_type_null_def__
+#ifndef __cxz_range_type_null_def__
+#define __cxz_range_type_null_def__
 
 namespace CNORXZ
 {   
@@ -89,8 +89,8 @@ namespace CNORXZ
 }
 
 
-#endif // #ifndef __range_type_null_def__
+#endif // #ifndef __cxz_range_type_null_def__
 
-#endif // #ifdef __ranges_header__
+#endif // #ifdef __cxz_ranges_header__
 
 #endif // #ifdef include_range_type
diff --git a/src/include/ranges/range_types/space_range.h b/src/include/ranges/range_types/space_range.h
index badc9d7..3c3c6a5 100644
--- a/src/include/ranges/range_types/space_range.h
+++ b/src/include/ranges/range_types/space_range.h
@@ -3,10 +3,10 @@
 include_range_type(PSPACE,3) // Periodic 1dim space
 #else
 
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 
-#ifndef __range_type_space_def__
-#define __range_type_space_def__
+#ifndef __cxz_range_type_space_def__
+#define __cxz_range_type_space_def__
 
 namespace CNORXZ
 {
@@ -128,8 +128,8 @@ namespace CNORXZ
     using MSpaceRF = decltype(CreateNDimSpaceRange<N>::template mkf<SpaceRange>());
 }
 
-#endif // #ifndef __range_type_space_def__
+#endif // #ifndef __cxz_range_type_space_def__
 
-#endif // #ifdef __ranges_header__
+#endif // #ifdef __cxz_ranges_header__
 
 #endif // #ifdef include_range_type
diff --git a/src/include/ranges/range_types/spin_range.h b/src/include/ranges/range_types/spin_range.h
index 256f9be..c88dcb7 100644
--- a/src/include/ranges/range_types/spin_range.h
+++ b/src/include/ranges/range_types/spin_range.h
@@ -4,11 +4,11 @@
 include_range_type(SPIN,2)
 #else
 
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 // assert, that this is only used within range_types/header.h
 
-#ifndef __range_type_spin_def__
-#define __range_type_spin_def__
+#ifndef __cxz_range_type_spin_def__
+#define __cxz_range_type_spin_def__
 
 namespace CNORXZ
 {
@@ -82,8 +82,8 @@ namespace CNORXZ
 }
 
 
-#endif // #ifndef __range_type_spin_def__
+#endif // #ifndef __cxz_range_type_spin_def__
 
-#endif // #ifdef __ranges_header__
+#endif // #ifdef __cxz_ranges_header__
 
 #endif // #ifdef include_range_type
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index 2aa04fa..57a1943 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __ranges_base_def_h__
-#define __ranges_base_def_h__
+#ifndef __cxz_ranges_base_def_h__
+#define __cxz_ranges_base_def_h__
 
 #include <cstdlib>
 
diff --git a/src/include/ranges/reg_ind_num.h b/src/include/ranges/reg_ind_num.h
index c7b9640..6fc4bd4 100644
--- a/src/include/ranges/reg_ind_num.h
+++ b/src/include/ranges/reg_ind_num.h
@@ -1,6 +1,6 @@
 
-#ifndef __reg_ind_num_h__
-#define __reg_ind_num_h__
+#ifndef __cxz_reg_ind_num_h__
+#define __cxz_reg_ind_num_h__
 
 
 
diff --git a/src/include/ranges/rheader.h b/src/include/ranges/rheader.h
index 6c88ee0..c9ea0c4 100644
--- a/src/include/ranges/rheader.h
+++ b/src/include/ranges/rheader.h
@@ -1,6 +1,6 @@
 
-//#ifndef __rheader_h__
-//#define __rheader_h__
+//#ifndef __cxz_rheader_h__
+//#define __cxz_rheader_h__
 
 #include "dynamic_range.h"
 #include "rpheader.h"
diff --git a/src/include/ranges/rpheader.h b/src/include/ranges/rpheader.h
index 3de270f..c6ecd37 100644
--- a/src/include/ranges/rpheader.h
+++ b/src/include/ranges/rpheader.h
@@ -1,6 +1,6 @@
 
-//#ifndef __rpheader_h__
-//#define __rpheader_h__
+//#ifndef __cxz_rpheader_h__
+//#define __cxz_rpheader_h__
 
 #include "single_range.h"
 #include "multi_range.h"
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index 17d5887..c6e417f 100644
--- a/src/include/ranges/single_range.h
+++ b/src/include/ranges/single_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __single_range_h__
-#define __single_range_h__
+#ifndef __cxz_single_range_h__
+#define __cxz_single_range_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/subrange.h b/src/include/ranges/subrange.h
index e34bea7..c1b128c 100644
--- a/src/include/ranges/subrange.h
+++ b/src/include/ranges/subrange.h
@@ -1,6 +1,6 @@
 
-#ifndef __subrange_h__
-#define __subrange_h__
+#ifndef __cxz_subrange_h__
+#define __cxz_subrange_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/type_map.h b/src/include/ranges/type_map.h
index 3f65c7b..5e41ad1 100644
--- a/src/include/ranges/type_map.h
+++ b/src/include/ranges/type_map.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_type_map_h__
-#define __ma_type_map_h__
+#ifndef __cxz_type_map_h__
+#define __cxz_type_map_h__
 
 #include <string>
 #include <vector>
diff --git a/src/include/ranges/value_range.h b/src/include/ranges/value_range.h
index db236e1..fd9b0ec 100644
--- a/src/include/ranges/value_range.h
+++ b/src/include/ranges/value_range.h
@@ -1,6 +1,6 @@
 
-#ifndef __value_range_h__
-#define __value_range_h__
+#ifndef __cxz_value_range_h__
+#define __cxz_value_range_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/x_to_string.h b/src/include/ranges/x_to_string.h
index aa66616..547d657 100644
--- a/src/include/ranges/x_to_string.h
+++ b/src/include/ranges/x_to_string.h
@@ -1,6 +1,6 @@
 
-#ifndef __x_to_string_h__
-#define __x_to_string_h__
+#ifndef __cxz_x_to_string_h__
+#define __cxz_x_to_string_h__
 
 #include <string>
 #include <vector>
diff --git a/src/include/slice.cc.h b/src/include/slice.cc.h
index 5a118e3..84a9338 100644
--- a/src/include/slice.cc.h
+++ b/src/include/slice.cc.h
@@ -17,7 +17,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     ConstSlice<T,SRanges...>::ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
 					 const T* data) :
-	MultiArrayBase<T,SRanges...>(ranges),
+	ArrayBase<T,SRanges...>(ranges),
 	mData(data)
     {
 	MAB::mInit = true;
@@ -25,15 +25,15 @@ namespace CNORXZ
     
     template <typename T, class... SRanges>
     ConstSlice<T,SRanges...>::ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data) :
-	MultiArrayBase<T,SRanges...>(ranges...),
+	ArrayBase<T,SRanges...>(ranges...),
 	mData(data)
     {
 	MAB::mInit = true;
     }
 
     template <typename T, class... SRanges>
-    ConstSlice<T,SRanges...>::ConstSlice(const MultiArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes) :
-	MultiArrayBase<T,SRanges...>
+    ConstSlice<T,SRanges...>::ConstSlice(const ArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes) :
+	ArrayBase<T,SRanges...>
 	( ma.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ),
 	mData( ma.data() )
     {
@@ -87,7 +87,7 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    std::shared_ptr<MultiArrayBase<T,AnonymousRange> > ConstSlice<T,SRanges...>::anonymous(bool slice) const
+    std::shared_ptr<ArrayBase<T,AnonymousRange> > ConstSlice<T,SRanges...>::anonymous(bool slice) const
     {
         assert(slice);
         assert(not MAB::mProtoI->sliceMode()); // only originally ordered slices!
@@ -118,13 +118,13 @@ namespace CNORXZ
     
     template <typename T, class... SRanges>
     Slice<T,SRanges...>::Slice(const std::shared_ptr<SRanges>&... ranges, T* data) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mData(data) {}
 
     template <typename T, class... SRanges>
     Slice<T,SRanges...>::Slice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
 			       T* data) :
-	MutableMultiArrayBase<T,SRanges...>(ranges),
+	MutableArrayBase<T,SRanges...>(ranges),
 	mData(data)
     {
 	MAB::mInit = true;
@@ -208,14 +208,14 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    std::shared_ptr<MultiArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymous(bool slice) const
+    std::shared_ptr<ArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymous(bool slice) const
     {
 	assert(0); // think about carefully!!!!
 	return nullptr;
     }
     /*
     template <typename T, class... SRanges>
-    std::shared_ptr<MultiArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymousMove()
+    std::shared_ptr<ArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymousMove()
     {
 	assert(0); // think about carefully!!!!
 	return nullptr;
diff --git a/src/include/slice.h b/src/include/slice.h
index 68b4c27..dbc9a01 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -1,6 +1,6 @@
 
-#ifndef __slice_h__
-#define __slice_h__
+#ifndef __cxz_slice_h__
+#define __cxz_slice_h__
 
 #include "cxz_array_base.h"
 #include "cxz_operation.h"
@@ -8,23 +8,23 @@
 namespace CNORXZ
 {
     template <typename T, class... SRanges>
-    class ConstSlice : public MultiArrayBase<T,SRanges...>
+    class ConstSlice : public ArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
-	using MultiArrayBase<T,SRanges...>::operator();
-        using MultiArrayBase<T,SRanges...>::operator[];
+	using ArrayBase<T,SRanges...>::operator();
+        using ArrayBase<T,SRanges...>::operator[];
 	
 	DEFAULT_MEMBERS(ConstSlice);
 
 	ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
 		   const T* data = nullptr);
 	ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data = nullptr);
-	ConstSlice(const MultiArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes);
+	ConstSlice(const ArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes);
 
 	virtual const T& operator[](const IType& i) const final;
 	virtual const T& at(const typename IType::MetaType& meta) const override;
@@ -36,7 +36,7 @@ namespace CNORXZ
 	virtual auto begin() const -> IType override;
 	virtual auto end() const -> IType override;
 
-	virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
 	
 	auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
 	    -> ConstSliceDef<T,SRanges...>;
@@ -51,18 +51,18 @@ namespace CNORXZ
 
     
     template <typename T, class... SRanges>
-    class Slice : public MutableMultiArrayBase<T,SRanges...>
+    class Slice : public MutableArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
-	using MultiArrayBase<T,SRanges...>::operator();
-	using MutableMultiArrayBase<T,SRanges...>::operator();
-        using MultiArrayBase<T,SRanges...>::operator[];
-	using MutableMultiArrayBase<T,SRanges...>::operator[];
+	using ArrayBase<T,SRanges...>::operator();
+	using MutableArrayBase<T,SRanges...>::operator();
+        using ArrayBase<T,SRanges...>::operator[];
+	using MutableArrayBase<T,SRanges...>::operator[];
 
 	DEFAULT_MEMBERS(Slice);
 
@@ -85,8 +85,8 @@ namespace CNORXZ
 	virtual auto begin() const -> IType override;
 	virtual auto end() const -> IType override;
 
-	virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
-	//virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymousMove() override;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
+	//virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymousMove() override;
 
 	auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
 	    -> SliceDef<T,SRanges...>;
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index d8758ed..63ff959 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -1,6 +1,6 @@
 
-#ifndef __static_for_h__
-#define __static_for_h__
+#ifndef __cxz_static_for_h__
+#define __cxz_static_for_h__
 
 #include <cstdlib>
 
diff --git a/src/include/statics/traits.h b/src/include/statics/traits.h
index 2a97631..9f16627 100644
--- a/src/include/statics/traits.h
+++ b/src/include/statics/traits.h
@@ -14,10 +14,10 @@ namespace CNORXZ
         static constexpr bool VALUE = true; \
     }
 
-    add_array_trait(MultiArrayBase);
-    add_array_trait(MutableMultiArrayBase);
-    add_array_trait(MultiArray);
-    add_array_trait(FunctionalMultiArray);
+    add_array_trait(ArrayBase);
+    add_array_trait(MutableArrayBase);
+    add_array_trait(Array);
+    add_array_trait(FunctionalArray);
     add_array_trait(Slice);
     add_array_trait(ConstSlice);
 
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index acebd59..60a6f74 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -1,6 +1,6 @@
 
-#ifndef __type_operations_h__
-#define __type_operations_h__
+#ifndef __cxz_type_operations_h__
+#define __cxz_type_operations_h__
 
 #include <cstdlib>
 #include <vector>
@@ -20,7 +20,7 @@ namespace CNORXZ
 	using namespace CNORXZInternal;
     }
 
-    // MultiArray
+    // Array
     
     template <typename T, class... Ranges>
     class operate
@@ -30,7 +30,7 @@ namespace CNORXZ
 
 	operate(const std::shared_ptr<typename Ranges::IndexType>&... inds) : ituple(inds...) {}
 	
-	inline auto apply(const MultiArray<T,Ranges...>& ma)
+	inline auto apply(const Array<T,Ranges...>& ma)
 	    -> OperationRoot<T,Ranges...>
 	{
 	    return unpack<0,sizeof...(Ranges),0>
@@ -46,9 +46,9 @@ namespace CNORXZ
     };
 
     template <class OperationClass, typename T, class... Ranges>
-    class OperationTemplate<MultiArray<T,Ranges...>,OperationClass> : public OperationBase<MultiArray<T,Ranges...>,OperationClass>
+    class OperationTemplate<Array<T,Ranges...>,OperationClass> : public OperationBase<Array<T,Ranges...>,OperationClass>
     {
-	typedef OperationBase<MultiArray<T,Ranges...>,OperationClass> OB;
+	typedef OperationBase<Array<T,Ranges...>,OperationClass> OB;
 	
 	auto operator()(const std::shared_ptr<typename Ranges::IndexType>&... indices)
 	    -> Operation<OperationRoot<T,Ranges...>,operate<T,Ranges...>,OperationClass>
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index fc72b50..1ff460a 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -1,6 +1,6 @@
 
-#ifndef __exttype_h__
-#define __exttype_h__
+#ifndef __cxz_exttype_h__
+#define __cxz_exttype_h__
 
 #include <array>
 
diff --git a/src/include/xfor/for_type.h b/src/include/xfor/for_type.h
index 7880ed7..6833c99 100644
--- a/src/include/xfor/for_type.h
+++ b/src/include/xfor/for_type.h
@@ -1,6 +1,6 @@
 
-#ifndef __for_type_h__
-#define __for_type_h__
+#ifndef __cxz_for_type_h__
+#define __cxz_for_type_h__
 
 namespace CNORXZInternal
 {
diff --git a/src/include/xfor/for_utils.h b/src/include/xfor/for_utils.h
index 5722d7e..453ea53 100644
--- a/src/include/xfor/for_utils.h
+++ b/src/include/xfor/for_utils.h
@@ -1,6 +1,6 @@
 
-#ifndef __for_utils_h__
-#define __for_utils_h__
+#ifndef __cxz_for_utils_h__
+#define __cxz_for_utils_h__
 
 //#include "ranges/rheader.h"
 #include <array>
diff --git a/src/include/xfor/iloop.h b/src/include/xfor/iloop.h
index c54aaad..8c74ae9 100644
--- a/src/include/xfor/iloop.h
+++ b/src/include/xfor/iloop.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_iloop_h__
-#define __ma_iloop_h__
+#ifndef __cxz_iloop_h__
+#define __cxz_iloop_h__
 
 #include <cstdlib>
 #include <memory>
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 2125538..3880b6c 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -1,6 +1,6 @@
 
-#ifndef __xfor_h__
-#define __xfor_h__
+#ifndef __cxz_xfor_h__
+#define __cxz_xfor_h__
 
 #include <cstdlib>
 #include <memory>
diff --git a/src/lib/ranges/anonymous_range.cc b/src/lib/ranges/anonymous_range.cc
index 9f2f652..acf7266 100644
--- a/src/lib/ranges/anonymous_range.cc
+++ b/src/lib/ranges/anonymous_range.cc
@@ -1,7 +1,7 @@
 
 #include "ranges/anonymous_range.h"
 #include "ranges/ranges_header.cc.h"
-#include "ma_assert.h"
+#include "cxz_assert.h"
 
 namespace CNORXZ
 {
diff --git a/src/lib/ranges/dynamic_range.cc b/src/lib/ranges/dynamic_range.cc
index fc02940..2ec7bfe 100644
--- a/src/lib/ranges/dynamic_range.cc
+++ b/src/lib/ranges/dynamic_range.cc
@@ -1,7 +1,7 @@
 
 #include "ranges/dynamic_range.h"
 #include "ranges/ranges_header.cc.h"
-#include "ma_assert.h"
+#include "cxz_assert.h"
 
 namespace CNORXZ
 {
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index bad8c59..fa99e9a 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -10,8 +10,8 @@ add_dependencies(autest multiarray)
 target_link_libraries(autest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
 add_test(NAME autest COMMAND autest)
 
-#add_executable(mautest src/tests/ma_unit_test.cc ${MA_CC_FILES})
-add_executable(mautest ma_unit_test.cc)
+#add_executable(mautest src/tests/array_unit_test.cc ${MA_CC_FILES})
+add_executable(mautest array_unit_test.cc)
 add_dependencies(mautest multiarray)
 target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
 add_test(NAME mautest COMMAND mautest)
diff --git a/src/tests/ma_unit_test.cc b/src/tests/array_unit_test.cc
similarity index 94%
rename from src/tests/ma_unit_test.cc
rename to src/tests/array_unit_test.cc
index bc85a74..1fa0e55 100644
--- a/src/tests/ma_unit_test.cc
+++ b/src/tests/array_unit_test.cc
@@ -98,7 +98,7 @@ namespace {
 
     TEST_F(MATest_1Dim, SimpleCall)
     {
-	MultiArray<double,MATest_1Dim::SRange> ma(srptr, vv);
+	Array<double,MATest_1Dim::SRange> ma(srptr, vv);
 	EXPECT_EQ( ma.size(), 5u);
 	EXPECT_EQ( ma.isConst(), false);
 	EXPECT_EQ( ma.isSlice(), false);	
@@ -115,7 +115,7 @@ namespace {
     TEST_F(MATest_1Dim, ForLoop)
     {
 	vector<double> v2 = { 0.693 , 2.718, 3.141, 1.618, 9.98 };
-	MultiArray<double,MATest_1Dim::SRange> ma(srptr, std::move( v2 ) );
+	Array<double,MATest_1Dim::SRange> ma(srptr, std::move( v2 ) );
 	size_t cnt = 0;
 	for(auto el: ma){
 
@@ -142,7 +142,7 @@ namespace {
 	swapFactory<SRF>( rfbptr, { 'a', 'c', 'e', 'g', 'i' } );
 	std::shared_ptr<SRange> sr2 = std::dynamic_pointer_cast<SRange>( rfbptr->create() );
 	
-	MultiArray<double,MATest_1Dim::SRange> ma(srptr, vv);
+	Array<double,MATest_1Dim::SRange> ma(srptr, vv);
 	auto i = ma.cbegin();
 	EXPECT_EQ( ma[ i.at('x') ], 3.141);
 
@@ -158,7 +158,7 @@ namespace {
 
     TEST_F(MATest_MDim, SimpleCall)
     {
-	MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
+	Array<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
 	EXPECT_EQ( ma.size(), 24u );
 	EXPECT_EQ( ma.range()->dim(), 2u );
 
@@ -175,7 +175,7 @@ namespace {
     
     TEST_F(MATest_MDim, ReFormat)
     {
-	MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
+	Array<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
 
 	auto ma2 = ma.format( sr4ptr );
 	auto i = ma2.cbegin();
@@ -188,7 +188,7 @@ namespace {
 
     TEST_F(MATest_MDim, SliceTest1)
     {
-	MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
+	Array<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
 	Slice<double,MATest_MDim::SRange> sl(sr3ptr);
 
 	auto i = MAT::getIndex(sr3ptr);
diff --git a/src/tests/op2_unit_test.cc b/src/tests/op2_unit_test.cc
index 4d5be4d..0e7eb7d 100644
--- a/src/tests/op2_unit_test.cc
+++ b/src/tests/op2_unit_test.cc
@@ -119,7 +119,7 @@ namespace
 
     TEST_F(MapTest, Exec1)
     {
-	MultiArray<double,SRange,SRange> ma1(sr1ptr,sr2ptr,v1);
+	Array<double,SRange,SRange> ma1(sr1ptr,sr2ptr,v1);
 
 
 	auto ii1 = getIndex( rptr<0>( ma1 ) );
@@ -127,8 +127,8 @@ namespace
         
         auto mr = mkMapR( mkMapOp(std::make_shared<plus<size_t>>(),ii1,ii2) , sr1ptr, sr2ptr );
 	//auto mr = mkMapR(std::make_shared<plus<size_t>>(),sr1ptr,sr2ptr);
-	MultiArray<double,MpRange> res(mr);
-	MultiArray<double,MpRange> res2(mr);
+	Array<double,MpRange> res(mr);
+	Array<double,MpRange> res2(mr);
 	auto jj = getIndex( mr );
 	(*jj)(ii1,ii2);
 	///auto jj = mkMapI( std::make_shared<plus<size_t> >(), ii1, ii1 );
@@ -137,8 +137,8 @@ namespace
 	auto mult = mr->explMapMultiplicity();
         res2(jj) += ma1(ii1,ii2) / staticcast<double>( mult(jj) );
 
-	MultiArray<double,TRange> form = res.format(mpr1ptr->outRange());
-	MultiArray<double,TRange> form2 = res2.format(mpr1ptr->outRange());
+	Array<double,TRange> form = res.format(mpr1ptr->outRange());
+	Array<double,TRange> form2 = res2.format(mpr1ptr->outRange());
 	
 	EXPECT_EQ( jj->range()->outRange()->size(), static_cast<size_t>( 10 ) );
  	EXPECT_EQ( jj->range()->mapMultiplicity().at(9), static_cast<size_t>( 3 ) );
@@ -169,7 +169,7 @@ namespace
     
     TEST_F(MetaOp_Test, SimpleCall)
     {
-	FunctionalMultiArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
+	FunctionalArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
 
 	auto i = fma.begin();
 	
@@ -178,8 +178,8 @@ namespace
 
     TEST_F(MetaOp_Test, Operation)
     {
-	FunctionalMultiArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
-	MultiArray<double,SR> res( sr1ptr );
+	FunctionalArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
+	Array<double,SR> res( sr1ptr );
 
 	auto i1 = MAT::getIndex(sr1ptr);
 	auto i2 = MAT::getIndex(sr2ptr);
@@ -203,14 +203,14 @@ namespace
 
     TEST_F(OpTest_Sub, Exec)
     {
-        MultiArray<double,SRange,SRange,SRange> ma1(sr1ptr, sr2ptr, sr3ptr, v1);
-        MultiArray<double,SRange,SRange> ma2(sr3ptr, sr2ptr, v2);
+        Array<double,SRange,SRange,SRange> ma1(sr1ptr, sr2ptr, sr3ptr, v1);
+        Array<double,SRange,SRange> ma2(sr3ptr, sr2ptr, v2);
 
         SubRangeFactory<SRange> subf(sr2ptr, vector<size_t>({0,2}));
         auto subptr = MAT::createExplicit(subf);
         
-        MultiArray<double,SRange,SRange> res(sr3ptr,sr1ptr,0.);
-	MultiArray<double,SRange,SubRange<SRange>,SRange> res2(sr3ptr,subptr,sr1ptr,0.);
+        Array<double,SRange,SRange> res(sr3ptr,sr1ptr,0.);
+	Array<double,SRange,SubRange<SRange>,SRange> res2(sr3ptr,subptr,sr1ptr,0.);
 
         auto i1 = MAT::getIndex( sr1ptr );
         auto i2 = MAT::getIndex( sr2ptr );
diff --git a/src/tests/op3_unit_test.cc b/src/tests/op3_unit_test.cc
index e211634..f69213a 100644
--- a/src/tests/op3_unit_test.cc
+++ b/src/tests/op3_unit_test.cc
@@ -31,9 +31,9 @@ namespace
 
     TEST_F(OpTest_Spin, Contract)
     {
-	MultiArray<double,SR,SR,SR,SR,SR,SR,SR,SR> ma(sr, sr, sr, sr, sr, sr, sr, sr, data);
-	MultiArray<double,SR,SR> res1( sr, sr );
-	MultiArray<double,SR,SR> res2( sr, sr );
+	Array<double,SR,SR,SR,SR,SR,SR,SR,SR> ma(sr, sr, sr, sr, sr, sr, sr, sr, data);
+	Array<double,SR,SR> res1( sr, sr );
+	Array<double,SR,SR> res2( sr, sr );
 	
 	auto alpha = MAT::getIndex<SR>();
 	auto beta = MAT::getIndex<SR>();
@@ -47,7 +47,7 @@ namespace
 	res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
 	//res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap);
 	std::clock_t end = std::clock();
-	std::cout << "MultiArray time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
+	std::cout << "Array time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
 		  << std::endl;
 
 	res2(delta, deltap).par() += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(alpha).c(beta).c(gamma);
diff --git a/src/tests/op4_unit_test.cc b/src/tests/op4_unit_test.cc
index 0dd6c16..de0436a 100644
--- a/src/tests/op4_unit_test.cc
+++ b/src/tests/op4_unit_test.cc
@@ -43,13 +43,13 @@ namespace
     {
     protected:
 
-	MultiArray<double,CR,DR> ma1;
-	MultiArray<double,CR,DR> ma2;
-	MultiArray<double,DR> ma3;
-	MultiArray<double,DR> ma5;
+	Array<double,CR,DR> ma1;
+	Array<double,CR,DR> ma2;
+	Array<double,DR> ma3;
+	Array<double,DR> ma5;
 
-	MultiArray<double,CR,DR> res1;
-	MultiArray<double,CR,DR> res2;
+	Array<double,CR,DR> res1;
+	Array<double,CR,DR> res2;
 
 	std::map<std::string,std::shared_ptr<IndexW>> imap;
 
diff --git a/src/tests/op_perf_test.cc b/src/tests/op_perf_test.cc
index 6e32837..6c8bf50 100644
--- a/src/tests/op_perf_test.cc
+++ b/src/tests/op_perf_test.cc
@@ -165,8 +165,8 @@ namespace {
 
     void OpTest_Spin::contract()
     {
-	MultiArray<double,SR,SR,SR,SR,SR,SR,SR,SR> ma( sr, sr, sr, sr, sr, sr, sr, sr, data);
-	MultiArray<double,CR,SR,SR> res1( cr, sr, sr );
+	Array<double,SR,SR,SR,SR,SR,SR,SR,SR> ma( sr, sr, sr, sr, sr, sr, sr, sr, data);
+	Array<double,CR,SR,SR> res1( cr, sr, sr );
 
         auto ii = MAT::getIndex<CR>(cr);
         auto jj = MAT::getIndex<CR>(cr);
@@ -221,7 +221,7 @@ namespace {
         //tcast<v256>(res1)(ii ,delta, deltap).par() += tcast<v256>(ma)(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
 	//}
         auto end = std::chrono::system_clock::now();
-	std::cout << "MultiArray time: " << std::chrono::duration<double>(end-begin).count()
+	std::cout << "Array time: " << std::chrono::duration<double>(end-begin).count()
 		  << std::endl;
 	
 	assert( xround(res1.at(mkts(0,0,0))) == xround(vres[0]) );
@@ -251,9 +251,9 @@ namespace {
 #ifndef ONLY_SPIN    
     void OpTest_Performance::PCheck()
     {
-	MultiArray<double,MRange> ma2(mrptr, cv2);
-	MultiArray<double,SRange> ma1(sr1ptr, cv1);
-	MultiArray<double,MRange> res(mrptr);
+	Array<double,MRange> ma2(mrptr, cv2);
+	Array<double,SRange> ma1(sr1ptr, cv1);
+	Array<double,MRange> res(mrptr);
 
 	auto si1 = MAT::getIndex(sr1ptr);
 	auto si2 = MAT::getIndex(sr2ptr);
@@ -265,7 +265,7 @@ namespace {
 	res(mi) = ma2(mi) * ma1(si1);
 
 	std::clock_t end = std::clock();
-	std::cout << "MultiArray time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
+	std::cout << "Array time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
 		  << std::endl;
 
 	vector<double> res2(vs1*vs2);
diff --git a/src/tests/op_unit_test.cc b/src/tests/op_unit_test.cc
index c0d0e5d..61e8e8c 100644
--- a/src/tests/op_unit_test.cc
+++ b/src/tests/op_unit_test.cc
@@ -35,7 +35,7 @@ namespace
 	typedef MRF::oType MRange;
 
 	typedef AnonymousRange ANO;
-	typedef MultiArray<double,ANO> AMA;
+	typedef Array<double,ANO> AMA;
 	
 	OpTest_MDim()
 	{
@@ -77,9 +77,9 @@ namespace
 
     TEST_F(OpTest_1Dim, ExecOp)
     {
-	MultiArray<double,SRange> ma1(srptr, v1);
-	MultiArray<double,SRange> ma2(srptr, v2);
-	MultiArray<double,SRange> res(srptr);
+	Array<double,SRange> ma1(srptr, v1);
+	Array<double,SRange> ma2(srptr, v2);
+	Array<double,SRange> res(srptr);
 
 	auto i = MAT::getIndex( srptr );
 	
@@ -94,10 +94,10 @@ namespace
     
     TEST_F(OpTest_MDim, ExecOp1)
     {
-	MultiArray<double,SRange,SRange> res(sr2ptr,sr4ptr);
-	MultiArray<double,SRange,SRange> res2(sr2ptr,sr4ptr);
-	const MultiArray<double,SRange> ma1(sr2ptr, v1);
-	const MultiArray<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange,SRange> res(sr2ptr,sr4ptr);
+	Array<double,SRange,SRange> res2(sr2ptr,sr4ptr);
+	const Array<double,SRange> ma1(sr2ptr, v1);
+	const Array<double,SRange> ma2(sr4ptr, v2);
 
 	auto i1 = MAT::getIndex( sr2ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -127,9 +127,9 @@ namespace
 
     TEST_F(OpTest_MDim, ExecContract)
     {
-	MultiArray<double,SRange> res(sr2ptr);
-	const MultiArray<double,SRange> ma1(sr2ptr, v1);
-	const MultiArray<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange> res(sr2ptr);
+	const Array<double,SRange> ma1(sr2ptr, v1);
+	const Array<double,SRange> ma2(sr4ptr, v2);
 
 	auto i1 = MAT::getIndex( sr2ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -143,10 +143,10 @@ namespace
     
     TEST_F(OpTest_MDim, ExecOp2)
     {
-	MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr);
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,SRange> ma2(sr4ptr, v2);
-	MultiArray<double,SRange> ma3(sr4ptr, v4);
+	Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange> ma3(sr4ptr, v4);
 	
 	auto i1 = MAT::getIndex( mr1ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -171,10 +171,10 @@ namespace
 
     TEST_F(OpTest_MDim, ExecOpAnon)
     {
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,AnonymousRange> maa
-	    = *std::dynamic_pointer_cast<MultiArray<double,AnonymousRange>>( ma1.anonymous() );
-	MultiArray<double,AnonymousRange> maa2( maa.template getRangePtr<0>() );
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,AnonymousRange> maa
+	    = *std::dynamic_pointer_cast<Array<double,AnonymousRange>>( ma1.anonymous() );
+	Array<double,AnonymousRange> maa2( maa.template getRangePtr<0>() );
 
 	auto ar = maa.template getRangePtr<0>();
 	auto i1 = MAT::getIndex( ar );
@@ -188,10 +188,10 @@ namespace
     
     TEST_F(OpTest_MDim, ExecFOp)
     {
-	MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr);
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,SRange> ma2(sr4ptr, v2);
-	MultiArray<double,SRange> ma3(sr4ptr, v4);
+	Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange> ma3(sr4ptr, v4);
 	
 	auto i1 = MAT::getIndex( mr1ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -216,13 +216,13 @@ namespace
 
     TEST_F(OpTest_MDim, ExecDOp)
     {
-	//typedef MultiArray<double,AnonymousRange> AMA;
-	typedef MultiArray<double,DynamicRange> DMA;
+	//typedef Array<double,AnonymousRange> AMA;
+	typedef Array<double,DynamicRange> DMA;
 	
-	MultiArray<double,MRange,SRange> ma1(mr1ptr,sr4ptr,v5);
-	MultiArray<double,SRange> ma2(sr2ptr,v1);
-	MultiArray<double,SRange,MRange> res(sr4ptr,mr1ptr);
-	MultiArray<double,MRange,SRange> res2(mr1ptr,sr4ptr);
+	Array<double,MRange,SRange> ma1(mr1ptr,sr4ptr,v5);
+	Array<double,SRange> ma2(sr2ptr,v1);
+	Array<double,SRange,MRange> res(sr4ptr,mr1ptr);
+	Array<double,MRange,SRange> res2(mr1ptr,sr4ptr);
 
 	DMA dma1 = *std::dynamic_pointer_cast<DMA>( dynamic( ma1 ) );
 	DMA dma2 = *std::dynamic_pointer_cast<DMA>( dynamic( ma2 ) );
@@ -285,13 +285,13 @@ namespace
 
     TEST_F(OpTest_MDim, ExecOp3)
     {
-	MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr);
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,SRange> ma2(sr2ptr, v1);
-	MultiArray<double,SRange> ma3(sr4ptr, v4);
-	MultiArray<double,SRange,SRange,SRange,SRange> ma4(sr1ptr,sr2ptr,sr3ptr,sr4ptr);
-	MultiArray<double,SRange> ma5(sr1ptr, v3);
-	MultiArray<double,SRange> ma6(sr3ptr, v2);
+	Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,SRange> ma2(sr2ptr, v1);
+	Array<double,SRange> ma3(sr4ptr, v4);
+	Array<double,SRange,SRange,SRange,SRange> ma4(sr1ptr,sr2ptr,sr3ptr,sr4ptr);
+	Array<double,SRange> ma5(sr1ptr, v3);
+	Array<double,SRange> ma6(sr3ptr, v2);
 	
 	auto si0 = MAT::getIndex( sr1ptr ); // 'x'
 	auto si1 = MAT::getIndex( sr2ptr ); // '1'
@@ -324,9 +324,9 @@ namespace
 	(*si3) = 0;
 	Slice<double,SRange,SRange> sl(sr4ptr,sr3ptr);
 	sl.define(si3,si2) = ma4(si0,si1,si2,si3);
-	MultiArrayBase<double,SRange,SRange>& slb = sl;
+	ArrayBase<double,SRange,SRange>& slb = sl;
 	
-	MultiArray<double,SRange,SRange> ma8(sr3ptr,sr4ptr);
+	Array<double,SRange,SRange> ma8(sr3ptr,sr4ptr);
 	//ma8(si2,si3) = ma4(si0,si1,si2,si3);
 	ma8(si2,si3) = slb(si3,si2);
 

From 7a24e328e750510ac1152c8d8ab6389b4f7236cc Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Wed, 28 Jul 2021 21:30:21 +0200
Subject: [PATCH 56/56] rename libmultiarray -> libcnorxz

---
 src/lib/CMakeLists.txt   | 54 ++++++++++++++++++++--------------------
 src/tests/CMakeLists.txt | 32 ++++++++++++------------
 2 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index 19f96df..681a337 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -2,7 +2,7 @@
 execute_process ( COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/mk_hl_op.sh
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ )
 
-set(libmultiarray_a_SOURCES
+set(libcnorxz_a_SOURCES
   ${CMAKE_SOURCE_DIR}/src/lib/ranges/range_base.cc
   ${CMAKE_SOURCE_DIR}/src/lib/ranges/anonymous_range.cc
   ${CMAKE_SOURCE_DIR}/src/lib/ranges/dynamic_meta.cc
@@ -12,64 +12,64 @@ set(libmultiarray_a_SOURCES
   ${CMAKE_SOURCE_DIR}/src/lib/map_range_factory_product_map.cc
   )
 
-set(libhlmultiarray_a_SOURCES
+set(libhlcnorxz_a_SOURCES
   ${CMAKE_SOURCE_DIR}/src/lib/high_level_operation.cc
   )
-#message(WARNING ${libhlmultiarray_a_SOURCES})
+#message(WARNING ${libhlcnorxz_a_SOURCES})
 
 file(GLOB cc_files "${CMAKE_SOURCE_DIR}/src/lib/ranges/range_types/*.cc")
 foreach(ccfile ${cc_files})
-  set(libmultiarray_a_SOURCES ${libmultiarray_a_SOURCES}
+  set(libcnorxz_a_SOURCES ${libcnorxz_a_SOURCES}
     ${ccfile})
 endforeach(ccfile)
 
 file(GLOB cc_files "${CMAKE_SOURCE_DIR}/src/lib/hl_ops/*.cc")
 foreach(ccfile ${cc_files})
-  set(libhlmultiarray_a_SOURCES ${libhlmultiarray_a_SOURCES}
+  set(libhlcnorxz_a_SOURCES ${libhlcnorxz_a_SOURCES}
     ${ccfile})
 endforeach(ccfile)
 
-add_library(multiarray_obj OBJECT
-  ${libmultiarray_a_SOURCES}
+add_library(cnorxz_obj OBJECT
+  ${libcnorxz_a_SOURCES}
   )
-add_library(hlmultiarray_obj OBJECT
-  ${libhlmultiarray_a_SOURCES}
+add_library(hlcnorxz_obj OBJECT
+  ${libhlcnorxz_a_SOURCES}
   )
-set_target_properties(multiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
-set_target_properties(hlmultiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(cnorxz_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(hlcnorxz_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
-add_library(multiarray SHARED
-  $<TARGET_OBJECTS:multiarray_obj>
+add_library(cnorxz SHARED
+  $<TARGET_OBJECTS:cnorxz_obj>
   )
-set_target_properties(multiarray PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(cnorxz PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
-add_library(multiarray_static
-  $<TARGET_OBJECTS:multiarray_obj>
+add_library(cnorxz_static
+  $<TARGET_OBJECTS:cnorxz_obj>
   )
-set_target_properties(multiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(cnorxz_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
-add_library(hlmultiarray SHARED
-  $<TARGET_OBJECTS:hlmultiarray_obj>
+add_library(hlcnorxz SHARED
+  $<TARGET_OBJECTS:hlcnorxz_obj>
   )
-set_target_properties(hlmultiarray PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(hlcnorxz PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
-add_library(hlmultiarray_static
-  $<TARGET_OBJECTS:hlmultiarray_obj>
+add_library(hlcnorxz_static
+  $<TARGET_OBJECTS:hlcnorxz_obj>
   )
-set_target_properties(hlmultiarray_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+set_target_properties(hlcnorxz_obj PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
-install(TARGETS multiarray
+install(TARGETS cnorxz
   ARCHIVE DESTINATION ${INSTALL_PATH}/lib
   LIBRARY DESTINATION ${INSTALL_PATH}/lib)
 
-install(TARGETS multiarray_static
+install(TARGETS cnorxz_static
   ARCHIVE DESTINATION ${INSTALL_PATH}/lib
   LIBRARY DESTINATION ${INSTALL_PATH}/lib)
 
-install(TARGETS hlmultiarray
+install(TARGETS hlcnorxz
   ARCHIVE DESTINATION ${INSTALL_PATH}/lib
   LIBRARY DESTINATION ${INSTALL_PATH}/lib)
 
-install(TARGETS hlmultiarray_static
+install(TARGETS hlcnorxz_static
   ARCHIVE DESTINATION ${INSTALL_PATH}/lib
   LIBRARY DESTINATION ${INSTALL_PATH}/lib)
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index fa99e9a..165a6bc 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -1,41 +1,41 @@
 
 #add_executable(iutest /ranges/index_unit_test.cc ${INDEX_CC_FILES})
 add_executable(iutest ranges/index_unit_test.cc)
-add_dependencies(iutest multiarray)
-target_link_libraries(iutest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(iutest cnorxz)
+target_link_libraries(iutest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz)
 add_test(NAME iutest COMMAND iutest)
 
 add_executable(autest ranges/anonymous_unit_test.cc)
-add_dependencies(autest multiarray)
-target_link_libraries(autest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(autest cnorxz)
+target_link_libraries(autest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz)
 add_test(NAME autest COMMAND autest)
 
 #add_executable(mautest src/tests/array_unit_test.cc ${MA_CC_FILES})
 add_executable(mautest array_unit_test.cc)
-add_dependencies(mautest multiarray)
-target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(mautest cnorxz)
+target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz)
 add_test(NAME mautest COMMAND mautest)
 
 add_executable(oputest op_unit_test.cc)
-add_dependencies(oputest multiarray)
-target_link_libraries(oputest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(oputest cnorxz)
+target_link_libraries(oputest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz)
 add_test(NAME oputest COMMAND oputest)
 
 add_executable(op2utest op2_unit_test.cc)
-add_dependencies(op2utest multiarray)
-target_link_libraries(op2utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(op2utest cnorxz)
+target_link_libraries(op2utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz)
 add_test(NAME op2utest COMMAND op2utest)
 
 add_executable(op3utest op3_unit_test.cc)
-add_dependencies(op3utest multiarray)
-target_link_libraries(op3utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
+add_dependencies(op3utest cnorxz)
+target_link_libraries(op3utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz)
 add_test(NAME op3utest COMMAND op3utest)
 
 add_executable(op4utest op4_unit_test.cc)
-add_dependencies(op4utest multiarray hlmultiarray)
-target_link_libraries(op4utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray hlmultiarray)
+add_dependencies(op4utest cnorxz hlcnorxz)
+target_link_libraries(op4utest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz hlcnorxz)
 add_test(NAME op4utest COMMAND op4utest)
 
 add_executable(opptest op_perf_test.cc)
-add_dependencies(opptest multiarray)
-target_link_libraries(opptest multiarray)
+add_dependencies(opptest cnorxz)
+target_link_libraries(opptest cnorxz)