fix some of the recently introduced compile errors

src/include/array/array.h

@@ -4,3 +4,5 @@
 #include "darray.h"
 #include "dcontainer_index.h"
 //#include "functional_array.h"
+
+#include "array.cc.h"

src/include/base/base.h

@@ -11,4 +11,6 @@
 #include "obj_handle.h"
 #include "dtype.h"
 
+#include "base.cc.h"
+
 #endif

src/include/base/dtype.cc.h

@@ -14,14 +14,14 @@ namespace CNORXZ
     template <typename T>
     DType::DType(const T& d) : mD(d)
     {
-	_mkToStr();
+	_mkToStr<T>();
     }
 
     template <typename T>
     DType& DType::operator=(const T& d)
     {
 	mD = d;
-	_mkToStr();
+	_mkToStr<T>();
 	return *this;
     }
 

src/include/base/obj_handle.cc.h

@@ -8,29 +8,29 @@ namespace CNORXZ
 {
     
     template <typename T>
-    ObjHandle<T>::ObjHandle() : mC(std::make_unique<T>()) {}
+    ObjHandle<T>::ObjHandle() {}
 
     template <typename T>
     ObjHandle<T>::ObjHandle(const T& a) : mC(std::make_unique<T>(a)) {}
 
     template <typename T>
-    ObjHandle<T>::ObjHandle(const Uptr<T>& a) : mC(a) {}
+    ObjHandle<T>::ObjHandle(Uptr<T>&& a) : mC(std::forward<Uptr<T>>(a)) {}
 
     template <typename T>
-    ObjHandle<T>::ObjHandle(const ObjHandle& a) : mC(std::make_unique<T>(*a.mC)) {}
+    ObjHandle<T>::ObjHandle(const ObjHandle& a) : mC(a.mC->copy()) {}
 
     template <typename T>
     ObjHandle<T>::ObjHandle(ObjHandle&& a) : mC(a.mC) {}
 
     template <typename T>
-    ObjHandle& ObjHandle<T>::operator=(const ObjHandle& a)
+    ObjHandle<T>& ObjHandle<T>::operator=(const ObjHandle& a)
     {
 	mC = std::make_unique<T>(*a.mC);
 	return *this;
     }
 
     template <typename T>
-    ObjHandle& ObjHandle<T>::operator=(ObjHandle&& a)
+    ObjHandle<T>& ObjHandle<T>::operator=(ObjHandle&& a)
     {
 	mC = a.mC;
 	return *this;

src/include/base/obj_handle.h

@@ -19,12 +19,12 @@ namespace CNORXZ
 
 	ObjHandle();
 	ObjHandle(const T& a);
-	ObjHandle(const Uptr<T>& a);
+	ObjHandle(Uptr<T>&& a);
 	ObjHandle(const ObjHandle& a);
 	ObjHandle(ObjHandle&& a);
 	ObjHandle& operator=(const ObjHandle& a);
 	ObjHandle& operator=(ObjHandle&& a);
-	
+
 	T& operator*();
 	T* operator->();
 	const T& operator*() const;

src/include/base/to_string.cc.h

@@ -8,7 +8,7 @@
 namespace CNORXZ
 {
     template <typename T>
-    String toString(const T& a)
+    String ToString<T>::func(const T& a)
     {
 	std::stringstream ss;
 	ss << a;
@@ -16,7 +16,7 @@ namespace CNORXZ
     }
 
     template <typename T>
-    String toString<vector<T>>(const vector& a)
+    String ToString<vector<T>>::func(const vector& a)
     {
 	std::stringstream ss;
 	ss << "[";
@@ -29,7 +29,7 @@ namespace CNORXZ
     }
 
     template <typename T, size_t N>
-    String toString<std::array<T,N>>(const std::array<T,N>& a)
+    String ToString<std::array<T,N>>::func(const std::array<T,N>& a)
     {
 	std::stringstream ss;
 	ss << "(";
@@ -42,11 +42,16 @@ namespace CNORXZ
     }
 
     template <>
-    String toString<DType>(const DType& a)
+    String ToString<DType>::func(const DType& a)
     {
 	return a.str();
     }
 
+    template <typename T>
+    String toString(const T& a)
+    {
+	return ToString::func(a);
+    }
 }
 
 #endif

src/include/base/to_string.h

@@ -3,21 +3,36 @@
 #define __cxz_to_string_h__
 
 #include "types.h"
-#include <array>
 
 namespace CNORXZ
 {
     template <typename T>
-    String toString(const T& a);
+    struct ToString
+    {
+	static String func(const T& a);
+    };
 
     template <typename T>
-    String toString<vector<T>>(const vector& a);
+    struct ToString<Vector<T>>
+    {
+	static String func(const Vector<T>& a);
+    };
 
-    template <typename T, size_t N>
+    template <typename T, SizeT N>
-    String toString<std::array<T,N>>(const std::array<T,N>& a);
+    struct ToString<Arr<T,N>>
+    {
+	static String func(const Arr<T,N>& a);
+    };
 
     template <>
-    String toString<DType>(const DType& a);
+    struct ToString<DType>
+    {
+	static String func(const DType& a);
+    };
+
+    template <typename T>
+    String toString(const T& a);
+
 }
 
 #endif

src/include/base/types.h

@@ -40,18 +40,32 @@ namespace CNORXZ
     template <typename... T>
     using Tuple = std::tuple<T...>;
 
-    template <typename... T>
+    template <SizeT I, typename... T>
-    using TupleElem = std::tuple_element<T...>;
+    using TupleElem = std::tuple_element<I,Tuple<T...>>;
 
     template <typename K, typename V>
     using Map = std::map<K,V>;
 
-    typedef std::typeinfo TypeInfo;
+    typedef std::type_info TypeInfo;
     
     /*********************
      *   library types   *
      *********************/
 
+    /***
+	Naming Prefixes:
+	D = Y = Dynamic
+	V = X = Virtual
+	S = Static
+	P = Partial = Sub
+	C = Classic
+	M = Multi or !const
+	U = One(=Uni) dimensional
+	N = None = Null
+	T = Thread
+	R = Rank
+     ***/
+    
     // definition: base/dtype.h
     class DType;
 
@@ -74,6 +88,7 @@ namespace CNORXZ
     class DPos;
 
     // definition: ranges/xfor/exttype.h
+    template <class PosT>
     class VPos;
 
     // definition: ranges/xfor/exttype.h
@@ -134,12 +149,16 @@ namespace CNORXZ
     // definition: ranges/xindex.h
     class XIndexBase; // dynamic index wrapper
 
+    typedef Sptr<XIndexBase> XIndexPtr;
+
     // definition: ranges/yrange.h
     class YRange; // dynamic multi range
     
     // definition: ranges/yrange.h
     class YIndex;
 
+    typedef Sptr<YIndex> YIndexPtr;
+    
     // definition: ranges/pindex.h
     template <class Index>
     class PIndex; // partial index (index over sub-ranges and permutations)

src/include/memory/allocator.h

@@ -19,11 +19,9 @@ namespace CNORXZ
     template <typename T>
     class Allocator
     {
-    private:
-	static SizeT sMemUsage;
-	
     public:
-	static SizeT memUsage() { return sMemUsage; }
+
+	typedef T value_type;
 	
 	static constexpr SizeT type_size = sizeof(T);	
 	static constexpr SizeT N = 32; // get from environment!!!
@@ -48,15 +46,6 @@ namespace CNORXZ
     template <class T, class U>
     bool operator!=(const Allocator<T>& a, const Allocator<U>& b);
 
-    template <typename T>
-    SizeT Allocator<T>::sMemUsage = 0;
-    
-    
-    template <typename T>
-    inline SizeT memUsage()
-    {
-	return Allocator<T>::memUsage();
-    }
     
 } // namespace CNORXZ
 

src/include/memory/memcount.h

@@ -2,7 +2,6 @@
 #ifndef __cxz_memcount_h__
 #define __cxz_memcount_h__
 
-#include "allocator_d.h"
 #include "base/types.h"
 
 namespace CNORXZ
@@ -15,10 +14,11 @@ namespace CNORXZ
 	static void sub(SizeT x) { sMemUsage -= x; }
 	
     public:
-	MemCount() = delete(); // static only
+	MemCount() = delete; // static only
 	static SizeT usage() { return sMemUsage; }
 
-	friend Allocator;
+	template <typename T>
+	friend class Allocator;
     };
 
 } // namespace CNORXZ

src/include/memory/memory.h

@@ -1,3 +1,5 @@
 
 #include "allocator.h"
 #include "memcount.h"
+
+#include "memory.cc.h"

src/include/ranges/index_base.h

@@ -72,7 +72,7 @@ namespace CNORXZ
 	IndexInterface& operator=(IndexInterface&& in);
 	IndexInterface(SizeT pos);
 
-	IndexPtr mRel = nullptr;
+	IndexPtr<I,MetaType> mRel = nullptr;
 	SizeT mPos = 0;
 	PtrId mPtrId = 0;
     };

src/include/ranges/range_base.h

@@ -4,6 +4,9 @@
 #define __cxz_range_base_h__
 
 #include "base/base.h"
+#include "base/base.cc.h"
+#include "memory/memory.h"
+#include "memory/memory.cc.h"
 
 namespace CNORXZ
 {
@@ -29,7 +32,7 @@ namespace CNORXZ
     private:
 	// also add single ranges here (PtrId -> own)
 	// rangeCast: PtrId -> original Range
-	static Map<TypeInfo,Map<Vector<PtrId>,RangePtr>> sCreated;
+	static Map<SizeT,Map<Vector<PtrId>,RangePtr>> sCreated;
 	
     };
 

src/include/ranges/ranges.h

@@ -8,3 +8,5 @@
 //#include "value_range.h"
 #include "xindex.h"
 #include "yindex.h"
+
+#include "ranges.cc.h"

src/include/ranges/xfor/exttype.h

@@ -2,9 +2,9 @@
 #ifndef __cxz_exttype_h__
 #define __cxz_exttype_h__
 
-#include <array>
+#include "base/base.h"
 
-namespace CNORXZInternal
+namespace CNORXZ
 {
 
     // Dynamic Ext: ObjHandl<ExtBase>
@@ -14,7 +14,8 @@ namespace CNORXZInternal
     {
     public:
 	DEFAULT_MEMBERS(VPosBase);
-        
+
+	virtual Uptr<VPosBase> copy() const = 0;
 	virtual SizeT vsize() const = 0;
 	virtual const SizeT& vval() const = 0;
 	virtual VPosBase& vzero() = 0;
@@ -31,9 +32,9 @@ namespace CNORXZInternal
 	PosT& THIS() { return static_cast<PosT&>(*this); }
 	const PosT& THIS() const { return static_cast<const PosT&>(*this); }
 	
-	inline SizeT size() const { THIS().size(); }
+	inline SizeT size() const { return THIS().size(); }
-	inline const SizeT& val() const { THIS().val(); }
+	inline const SizeT& val() const { return THIS().val(); }
-	inline auto next() const { THIS().next(); }
+	inline auto next() const { return THIS().next(); }
 	inline bool operator==(const PosInterface<PosT>& a) const { return val() == a.val() and next() == a.next(); }
 	inline bool operator!=(const PosInterface<PosT>& a) const { return val() != a.val() or next() != a.next(); }
 	inline bool operator==(SizeT a) const { return val() == a and next() == a; }
@@ -51,18 +52,18 @@ namespace CNORXZInternal
     {
     public:
 	DEFAULT_MEMBERS(DPos);
-	DPos(Uptr<VPosBase> a) : ObjHandle<VPosBase>(a) {}
+	DPos(Uptr<VPosBase>&& a) : ObjHandle<VPosBase>(std::forward<Uptr<VPosBase>>(a)) {}
 
 	template <class PosT>
 	DPos(const PosT& a) : ObjHandle<VPosBase>( std::make_unique<PosT>(a) ) {}
-	
+
 	inline SizeT size() const { return mC->vsize(); }
 	inline const SizeT& val() const { return mC->vval(); }
 	inline DPos& zero() { mC->vzero(); return *this; }
 
 	template <class P>
 	inline DPos extend(const PosInterface<P>& a) const
-	{ /* append MPos<NPos> in static for loop over entries */ }
+	{ return DPos();/* append MPos<NPos> in static for loop over entries */ }
     };
 
     /*
@@ -104,13 +105,14 @@ namespace CNORXZInternal
 	
 	VPos(const PosInterface<PosT>& a) : PosT(a.THIS()) {}
 	
-	virtual SizeT vsize() const override final { return THIS().size(); }
+	virtual Uptr<VPosBase> copy() const override final { return std::make_unique<VPos>(*this); }
-	virtual const SizeT& vval() const override final { return THIS().val(); }
+	virtual SizeT vsize() const override final { return PosT::THIS().size(); }
-	virtual VPos& vzero() override final { THIS().zero(); return *this; }
+	virtual const SizeT& vval() const override final { return PosT::THIS().val(); }
+	virtual VPos& vzero() override final { PosT::THIS().zero(); return *this; }
 	virtual Uptr<VPosBase> vextend(const DPos& a) const override final
-	{ return std::make_unique<VPosBase>( THIS().extend(a) ); }
+	{ return std::make_unique<VPosBase>( PosT::THIS().extend(a) ); }
 	virtual Uptr<VPosBase> vextend(const MPos<NPos>& a) const override final
-	{ return std::make_unique<VPosBase>( THIS().extend(a) ); } // ??? if that works it would be a miracle ???
+	{ return std::make_unique<VPosBase>( PosT::THIS().extend(a) ); } // ??? if that works it would be a miracle ???
 	// .... probably I need to define a static instanciation limit...
 
     };
@@ -268,7 +270,7 @@ namespace CNORXZInternal
     
     inline MPos<NPos> mkExt(SizeT s) { return MPos<NPos>(s); }
 
-
+    /*
     template <size_t I, class X>
     auto getX(const MPos<X>& et)
     {
@@ -315,6 +317,7 @@ namespace CNORXZInternal
     {
 	return getX<I>(et).get();
     }
+    */
 
 } // end namespace CNORXZInternal
 
@@ -322,17 +325,17 @@ namespace CNORXZInternal
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-namespace CNORXZInternal
+namespace CNORXZ
 {
 
     template <class X>
     inline MPos<X>::MPos(size_t ext, X next) : mExt(ext), mNext(next) {}
-
+    /*
     template <class X>
     template <size_t N>
     inline MPos<X>::MPos(const std::array<size_t,N>& arr) :
 	mExt(std::get<NUM>(arr)), mNext(arr) {}
-
+    */
     template <class X>
     template <class Z>
     inline MPos<X>::MPos(size_t y, const Z& z) :
@@ -366,14 +369,14 @@ namespace CNORXZInternal
 	mExt = 0u;
 	mNext.zero();
     }
-
+    /*
     template <class X>
     template <size_t N>
     inline auto MPos<X>::nn() const
     {
 	return getX<N>(*this);
     }
-
+    */
     template <class X>
     inline MPos<X> MPos<X>::operator+(const MPos<X>& in) const
     {
@@ -407,12 +410,12 @@ namespace CNORXZInternal
     inline MPos<NPos>::MPos(const Y& y, const Z& z) :
 	mExt(y.val()) {}
 
-
+    /*
     //template <>
     template <size_t N>
     inline MPos<NPos>::MPos(const std::array<size_t,N>& arr) :
 	mExt(std::get<NUM>(arr)) {}
-
+    */
     template <class Y>
     inline MPos<NPos>::MPos(const MPos<Y>& y) :
         mExt(y.val()) {}
@@ -422,13 +425,13 @@ namespace CNORXZInternal
     {
 	mExt = 0u;
     }
-
+    /*
     template <size_t N>
     inline auto MPos<NPos>::nn() const
     {
 	return getX<N>(*this);
     }
-
+    */
     inline const size_t& MPos<NPos>::val() const
     {
 	return mExt;
@@ -450,14 +453,14 @@ namespace CNORXZInternal
     {
 	return MPos<NPos>(mExt * in);
     }
-
+    /*
     template <class X>
     template <size_t N>
     inline auto DVPosX<X>::nn() const
     {
 	return getX<N>(*this);
     }
-
+    */
 } // end namespace CNORXZInternal
 
 

src/include/ranges/xfor/xfor.h

@@ -21,7 +21,7 @@ namespace CNORXZ
 	DEFAULT_MEMBERS(ExprInterface);
 
 	Xpr& THIS() { return static_cast<Xpr&>(*this); }
-	const Xpr& THIS() const { return static_cast<const Expr&>(*this); }
+	const Xpr& THIS() const { return static_cast<const Xpr&>(*this); }
 
 	//Sptr<Expr> copy() const { THIS().copy(); }
 	
@@ -37,29 +37,34 @@ namespace CNORXZ
     public:
 	DEFAULT_MEMBERS(VExprBase);
 
-	virtual void vexec(SizeT mlast, PosT last) = 0;
+	virtual Uptr<VExprBase> copy() const = 0;
+	
+	virtual void vexec(SizeT mlast, DPos last) = 0;
 	virtual void vexec(SizeT mlast) = 0;
 
 	virtual DPos vrootSteps(PtrId ptrId) const = 0;
 	virtual DPos vextension() const = 0;
     };
 
-    template <class Xpr>
+    template <class Xpr, class PosT>
     class VExpr : public VExprBase, public Xpr
     {
     public:
+	typedef ExprInterface<Xpr,PosT> EI;
 	DEFAULT_MEMBERS(VExpr);
-	VExpr(const ExprInterface<Xpr>& a) : Xpr(a.THIS()) {}
+	VExpr(const ExprInterface<Xpr,PosT>& a) : Xpr(a.THIS()) {}
 
-	virtual void vexec(SizeT mlast, PosT last) override final { THIS()(mlast,last); }
+	virtual Uptr<VExprBase> copy() const override final { return std::make_unique<VExpr>(*this); }
-	virtual void vexec(SizeT mlast) override final { THIS()(mlast); }
 
-	virtual DPos vrootSteps(PtrId ptrId) const override final { return THIS().rootSteps(ptrId); }
+	virtual void vexec(SizeT mlast, DPos last) override final { EI::THIS()(mlast,last); }
-	virtual DPos vextension() const override final { return THIS().extension(); }
+	virtual void vexec(SizeT mlast) override final { EI::THIS()(mlast); }
+
+	virtual DPos vrootSteps(PtrId ptrId) const override final { return EI::THIS().rootSteps(ptrId); }
+	virtual DPos vextension() const override final { return EI::THIS().extension(); }
     };
     
     class DExpr : public ObjHandle<VExprBase>,
-		  public ExprInterface<DExpr>
+		  public ExprInterface<DExpr,DPos>
     {
     public:
 	DEFAULT_MEMBERS(DExpr);
@@ -70,7 +75,7 @@ namespace CNORXZ
 	inline DPos rootSteps(PtrId ptrId) const { return mC->vrootSteps(ptrId); }
 	inline DPos extension() const { return mC->vextension(); }
     };
-    
+    /*
     template <ForType FT = ForType::DEFAULT>
     struct PosForward
     {
@@ -106,7 +111,7 @@ namespace CNORXZ
 	SubExpr() = default;
 
 	const IndexClass* mIndPtr;
-	std::intptr_t mSIPtr;
+	PtrId mSIPtr;
 	size_t mSPos;
 	size_t mMax;
 
@@ -114,7 +119,7 @@ namespace CNORXZ
 	typedef decltype(mkExt(0).extend(mExpr.rootSteps())) ExtType;
 	ExtType mExt;
 
-        const vector<size_t>* mSubSet;
+        const Vector<SizeT>* mSubSet;
         
         mutable ExtType mRootSteps;
 
@@ -144,7 +149,7 @@ namespace CNORXZ
         auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
 	auto extension() const -> ExtType;
     };
-    /*
+
     template <ForType FT, size_t LAYER>
     struct NHLayer
     {
@@ -174,7 +179,7 @@ namespace CNORXZ
 	    return Expr::LAYER;
 	}
     };
-    */
+
     template <class IndexClass, class Expr, ForType FT, size_t DIV>
     class For : public ExpressionBase
     {
@@ -290,26 +295,21 @@ namespace CNORXZ
 
     };
 
+    */
 } 
 
 /* ========================= *
  * ---   TEMPLATE CODE   --- *
  * ========================= */
 
-#include <iostream>
 
-namespace CNORXZInternal
+namespace CNORXZ
 {
-    template <class ExtType>
-    const ExtType& ExtBase::expl() const
-    {
-	return dynamic_cast<const ExtT<ExtType>*>(this)->ext();
-    }
     
     /*****************
      *     F o r     *
      *****************/
-    
+    /*
     template <class IndexClass, class Expr, ForType FT, size_t DIV>
     For<IndexClass,Expr,FT,DIV>::For(const Sptr<IndexClass>& indPtr,
 				 size_t step, Expr expr) :
@@ -402,11 +402,11 @@ namespace CNORXZInternal
         static_assert(FT == ForType::DEFAULT, "hidden for not parallelizable");
         return PFor<IndexClass,Expr,DIV>(mIndPtr, mStep, mExpr);
     }
-    
+    */
     /******************
      *    P F o r     *
      ******************/
-    
+    /*
     template <class IndexClass, class Expr, size_t DIV>
     PFor<IndexClass,Expr,DIV>::PFor(const Sptr<IndexClass>& indPtr,
 				 size_t step, Expr expr) :
@@ -508,98 +508,12 @@ namespace CNORXZInternal
         //return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
 	//					    sizeof(ExtType)/sizeof(size_t));
     }
-
+    */
-    /************************
-     *   SingleExpression   *
-     ************************/
-    
-    template <class IndexClass, class Expr>
-    SingleExpression<IndexClass,Expr>::SingleExpression(const Sptr<IndexClass>& indPtr,
-							Expr expr) :
-	mIndPtr(indPtr.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
-        mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
-    {
-	assert(mIndPtr != nullptr);
-	//VCHECK(mIndPtr->id());
-	//VCHECK(mIndPtr->max());
-    }
-
-    template <class IndexClass, class Expr>
-    SingleExpression<IndexClass,Expr>::SingleExpression(const IndexClass* indPtr,
-				 Expr expr) :
-	mIndPtr(indPtr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
-        mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
-    {
-	assert(mIndPtr != nullptr);
-	//VCHECK(mIndPtr->id());
-	//VCHECK(mIndPtr->max());
-    }
-
-    template <class IndexClass, class Expr>
-    inline void SingleExpression<IndexClass,Expr>::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 SingleExpression<IndexClass,Expr>::operator()(size_t mlast,
-							      ExtType last)
-    {
-	//typedef typename IndexClass::RangeType RangeType;
-	const size_t pos = mIndPtr->pos();
-	const size_t mnpos = PosForward<ForType::DEFAULT>::value(mlast, mMax, pos);
-	const ExtType npos = last + mExt*pos;
-	mExpr(mnpos, npos);
-    }
-
-    template <class IndexClass, class Expr>
-    inline void SingleExpression<IndexClass,Expr>::operator()(size_t mlast)
-    {
-	//typedef typename IndexClass::RangeType RangeType;
-	ExtType last = rootSteps();
-	last.zero();
-	const size_t pos = mIndPtr->pos();
-	const size_t mnpos = PosForward<ForType::DEFAULT>::value(mlast, mMax, pos);
-	const ExtType npos = last + mExt*pos;
-	mExpr(mlast, last);
-    }
-
-    template <class IndexClass, class Expr>
-    auto SingleExpression<IndexClass,Expr>::rootSteps(std::intptr_t iPtrNum) const
-	-> ExtType
-    {
-	return mExpr.rootSteps(iPtrNum);
-    }
-
-    template <class IndexClass, class Expr>
-    auto SingleExpression<IndexClass,Expr>::extension() const
-	-> ExtType
-    {
-	return mExt;
-    }
-
-    template <class IndexClass, class Expr>
-    DExt SingleExpression<IndexClass,Expr>::dRootSteps(std::intptr_t iPtrNum) const
-    {
-        return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
-        //mRootSteps = rootSteps(iPtrNum);
-        //return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
-	//					    sizeof(ExtType)/sizeof(size_t));
-    }
-
-    template <class IndexClass, class Expr>
-    DExt SingleExpression<IndexClass,Expr>::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));
-    }
     
     /****************
      *   SubExpr    *
      ****************/
-
+    /*
     template <class IndexClass, class Expr>
     SubExpr<IndexClass,Expr>::SubExpr(const Sptr<IndexClass>& indPtr,
 				      std::intptr_t siptr,
@@ -682,11 +596,11 @@ namespace CNORXZInternal
         //return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
 	//					    sizeof(ExtType)/sizeof(size_t));
     }
-
+    */
     /***************************
      *   DynamicExpression   *
      ***************************/
-
+    /*
     inline void DynamicExpression::operator()(size_t mlast, DExt last)
     {
 	(*mNext)(mlast,last);
@@ -707,62 +621,7 @@ namespace CNORXZInternal
         return mNext->dExtension();
     }
 
-    /************************
+    */
-     *   ExpressionHolder   *
-     ************************/
-
-    template <class Expr>
-    ExpressionHolder<Expr>::ExpressionHolder(DynamicExpression expr) : mExpr(expr) {}
-
-    template <class Expr>
-    inline void ExpressionHolder<Expr>::operator()(size_t mlast, DExt last)
-    {
-	mExpr(mlast,last);
-    }
-
-    template <class Expr>
-    inline void ExpressionHolder<Expr>::operator()(size_t mlast, ExtType last)
-    {
-	mExpr(mlast,
-              std::make_shared<ExtT<ExtType>>(last));
-    }
-
-    template <class Expr>
-    inline void ExpressionHolder<Expr>::operator()(size_t mlast)
-    {
-	mExpr(mlast);
-    }
-
-    template <class Expr>
-    DExt ExpressionHolder<Expr>::dRootSteps(std::intptr_t iPtrNum) const
-    {
-	return mExpr.dRootSteps(iPtrNum);
-    }
-
-    template <class Expr>
-    DExt ExpressionHolder<Expr>::dExtension() const
-    {
-	return mExpr.dExtension();
-    }
-
-    template <class Expr>
-    auto ExpressionHolder<Expr>::rootSteps(std::intptr_t iPtrNum) const
-	-> ExtType
-    {
-        return std::dynamic_pointer_cast<ExtT<ExtType>>(mExpr.dRootSteps(iPtrNum))->ext();
-	//return *reinterpret_cast<ExtType const*>( mExpr.dRootSteps(iPtrNum).first );
-    }
-
-    template <class Expr>
-    auto ExpressionHolder<Expr>::extension() const
-	-> ExtType
-    {
-        return std::dynamic_pointer_cast<ExtT<ExtType>>(mExpr.dExtension())->ext();
-	//return *reinterpret_cast<ExtType const*>( mExpr.dExtension().first );
-    }
-
-
-    
 } // namespace CNORXZInternal
 
 #endif

src/include/ranges/xindex.cc.h

@@ -14,7 +14,7 @@ namespace CNORXZ
     XIndex<Index,Meta>::XIndex(const IndexPtr<Index,Meta>& i) : mI(i) {}
 
     template <class Index, typename Meta>
-    XIndex<Index,Meta>& XIndex<Index,Meta>::operator=(size_t pos)
+    XIndex<Index,Meta>& XIndex<Index,Meta>::operator=(SizeT pos)
     {
 	*mI = pos;
 	return *this;
@@ -35,31 +35,31 @@ namespace CNORXZ
     }
 
     template <class Index, typename Meta>
-    int XIndex<Index,Meta>::pp(std::intptr_t idxPtrNum)
+    Int XIndex<Index,Meta>::pp(PtrId idxPtrNum)
     {
 	return mI->pp(idxPtrNum);
     }
 
     template <class Index, typename Meta>
-    int XIndex<Index,Meta>::mm(std::intptr_t idxPtrNum)
+    Int XIndex<Index,Meta>::mm(PtrId idxPtrNum)
     {
 	return mI->mm(idxPtrNum);
     }
 
     template <class Index, typename Meta>
-    size_t XIndex<Index,Meta>::dim() const
+    SizeT XIndex<Index,Meta>::dim() const
     {
 	return mI->dim();
     }
 
     template <class Index, typename Meta>
-    size_t XIndex<Index,Meta>::getStepSize(size_t n) const
+    SizeT XIndex<Index,Meta>::getStepSize(SizeT n) const
     {
 	return mI->getStepSize(n);
     }
 
     template <class Index, typename Meta>
-    std::string XIndex<Index,Meta>::stringMeta() const
+    String XIndex<Index,Meta>::stringMeta() const
     {
 	return mI->stringMeta();
     }
@@ -79,13 +79,13 @@ namespace CNORXZ
     }
 
     template <class Index, typename Meta>
-    DynamicExpression XIndex<Index,Meta>::ifor(size_t step, DynamicExpression ex) const
+    DExpr XIndex<Index,Meta>::ifor(SizeT step, DExpr ex) const
     {
 	return mI->ifor(step, ex);
     }
 
     template <class Index, typename Meta>
-    DynamicExpression XIndex<Index,Meta>::iforh(size_t step, DynamicExpression ex) const
+    DExpr XIndex<Index,Meta>::iforh(SizeT step, DExpr ex) const
     {
 	return mI->iforh(step, ex);
     }

src/include/ranges/xindex.h

@@ -14,25 +14,21 @@ namespace CNORXZ
     public:
 	DEFAULT_MEMBERS(XIndexBase);
 
-	constexpr IndexType type() const;
+	virtual XIndexBase& operator=(SizeT pos) = 0;
-
-	virtual XIndexBase& operator=(size_t pos) = 0;
 	virtual XIndexBase& operator++() = 0;
 	virtual XIndexBase& operator--() = 0;
-	virtual int pp(std::intptr_t idxPtrNum) = 0;
+	virtual Int pp(PtrId idxPtrNum) = 0;
-	virtual int mm(std::intptr_t idxPtrNum) = 0;
+	virtual Int mm(PtrId idxPtrNum) = 0;
 	virtual size_t dim() const = 0;
-	virtual size_t getStepSize(size_t n) const = 0;
+	virtual size_t getStepSize(SizeT n) const = 0;
-	virtual std::string stringMeta() const = 0;
+	virtual String stringMeta() const = 0;
 	virtual DType meta() const = 0;
 	virtual XIndexBase& at(const DType& meta) = 0;
-	virtual DynamicExpression ifor(size_t step, DynamicExpression ex) const = 0;
+	virtual DExpr ifor(SizeT step, DExpr ex) const = 0;
-	virtual DynamicExpression iforh(size_t step, DynamicExpression ex) const = 0;
+	virtual DExpr iforh(SizeT step, DExpr ex) const = 0;
 	// ...!!!
     };
 
-    typedef std::shared_ptr<XIndexBase> XIndexPtr;
-    
     // MultiIndex Wrapper:
     template <class Index, typename Meta>
     class XIndex : public XIndexBase
@@ -44,18 +40,18 @@ namespace CNORXZ
 	DEFAULT_MEMBERS(XIndex);
 	XIndex(const IndexPtr<Index,Meta>& i);
 
-	virtual XIndex& operator=(size_t pos) override;
+	virtual XIndex& operator=(SizeT pos) override;
 	virtual XIndex& operator++() override;
 	virtual XIndex& operator--() override;
-	virtual int pp(std::intptr_t idxPtrNum) override;
+	virtual Int pp(PtrId idxPtrNum) override;
-	virtual int mm(std::intptr_t idxPtrNum) override;
+	virtual Int mm(PtrId idxPtrNum) override;
-	virtual size_t dim() const override;
+	virtual SizeT dim() const override;
-	virtual size_t getStepSize(size_t n) const override;
+	virtual SizeT getStepSize(SizeT n) const override;
-	virtual std::string stringMeta() const override;
+	virtual String stringMeta() const override;
 	virtual DType meta() const override;
 	virtual XIndexBase& at(const DType& meta) override;
-	virtual DynamicExpression ifor(size_t step, DynamicExpression ex) const override;
+	virtual DExpr ifor(SizeT step, DExpr ex) const override;
-	virtual DynamicExpression iforh(size_t step, DynamicExpression ex) const override;
+	virtual DExpr iforh(SizeT step, DExpr ex) const override;
 	// ....!!!!
     };
 

src/include/ranges/yindex.h

@@ -3,46 +3,47 @@
 #define __cxz_yindex_h__
 
 #include "base/base.h"
-#include "ranges/range_base.h"
+#include "range_base.h"
-#include "ranges/index_base.h"
+#include "index_base.h"
+#include "xindex.h"
 #include "xfor/xfor.h"
 
 namespace CNORXZ
 {
     // Future DynamicIndex
-    //class YIndex : public IndexInterface<YIndex,DType>
+    //class YIndex : public XIndexBase
-    class YIndex : public XIndexBase
+    class YIndex : public IndexInterface<YIndex,DType>
     {
     public:
 	typedef IndexInterface<YIndex,DType> IB;
 	
     private:
 	RangePtr mRange;
-	vector<XIndexPtr> mIs;
+	Vector<XIndexPtr> mIs;
-	std::vector<size_t> mBlockSizes; // dim() elements only!!!
+	Vector<SizeT> mBlockSizes; // dim() elements only!!!
 	bool mExternalControl = false;
 
     public:
 
 	DEFAULT_MEMBERS(YIndex);
 	YIndex(const RangePtr& range);
-	YIndex(const RangePtr& range, const std::vector<XIndexPtr>& is);
+	YIndex(const RangePtr& range, const Vector<XIndexPtr>& is);
 
-    	YIndex& operator=(size_t pos);
+	YIndex& sync();
+    	YIndex& operator=(SizeT pos);
 	YIndex& operator++();
 	YIndex& operator--();
-	int pp(std::intptr_t idxPtrNum);
+	int pp(PtrId idxPtrNum);
-	int mm(std::intptr_t idxPtrNum);
+	int mm(PtrId idxPtrNum);
 	size_t dim() const;
-	size_t getStepSize(size_t n) const;
+	size_t getStepSize(SizeT n) const;
-	std::string stringMeta() const;
+	String stringMeta() const;
 	DType meta() const;
 	YIndex& at(const DType& meta);
-	DynamicExpression ifor(size_t step, DynamicExpression ex) const;
+	DExpr ifor(SizeT step, DExpr ex) const;
-	DynamicExpression iforh(size_t step, DynamicExpression ex) const;
+	DExpr iforh(SizeT step, DExpr ex) const;
     };
 
-    typedef std::shared_ptr<YIndex> YIndexPtr;
 }
 
 #endif

src/lib/ranges/range_base.cc

@@ -8,11 +8,11 @@ namespace CNORXZ
      *   RangeFactoryBase    *
      *************************/
 
-    static Map<TypeInfo,Map<Vector<PtrId>,RangePtr>> RangeFactoryBase::sCreated;
+    Map<SizeT,Map<Vector<PtrId>,RangePtr>> RangeFactoryBase::sCreated;
     
     RangePtr RangeFactoryBase::create()
     {
-	mProd = this->make();
+	this->make();
 	mProd->mThis = mProd;
 	return mProd;
     }	
@@ -20,9 +20,9 @@ namespace CNORXZ
     RangePtr RangeFactoryBase::fromCreated(const TypeInfo& info, const Vector<PtrId>& rids) const
     {
 	RangePtr out = nullptr;
-	if(sCreated.count(info) != 0){
+	if(sCreated.count(info.hash_code()) != 0){
-	    if(sCreated[info].count(rids) != 0){
+	    if(sCreated[info.hash_code()].count(rids) != 0){
-		out = sCreated[info][rids];
+		out = sCreated[info.hash_code()][rids];
 	    }
 	}
 	return out;
@@ -30,7 +30,7 @@ namespace CNORXZ
 
     void RangeFactoryBase::addToCreated(const TypeInfo& info, const Vector<PtrId>& rids, const RangePtr& r)
     {
-	sCreated[info][rids] = r;
+	sCreated[info.hash_code()][rids] = r;
     }
     
     /******************

src/lib/ranges/yindex.cc

@@ -4,19 +4,23 @@
 namespace CNORXZ
 {
     YIndex::YIndex(const RangePtr& range) :
-	mIs(mRange.dim()), mBlockSizes(mRange.dim()), mExternalControl(false)
+	mRange(range), mIs(mRange->dim()),
+	mBlockSizes(mRange->dim()), mExternalControl(false)
     {
+	assert(0);
 	// init ...!!!
     }
 
     YIndex::YIndex(const RangePtr& range, const Vector<XIndexPtr>& is) :
-	mIs(is), mBlockSizes(mRange.dim()), mExternalControl(false)
+	mRange(range), mIs(is),
+	mBlockSizes(mRange->dim()), mExternalControl(false)
     {
-	CXZ_ASSERT(mIs.size() == mRange.dim(), "obtained wrong number of indices");
+	CXZ_ASSERT(mIs.size() == mRange->dim(), "obtained wrong number of indices");
+	assert(0);
 	// init ...!!!
     }
 
-    YIndex& YIndex::operator=(size_t pos)
+    YIndex& YIndex::operator=(SizeT pos)
     {
 	IB::mPos = pos;
 	// sub inds... (LAZY!!!) !!!
@@ -39,24 +43,27 @@ namespace CNORXZ
 	return *this;
     }
     
-    int YIndex::pp(std::intptr_t idxPtrNum)
+    Int YIndex::pp(PtrId idxPtrNum)
     {
-	
+	assert(0);
+	return 0;
     }
     
-    int YIndex::mm(std::intptr_t idxPtrNum)
+    Int YIndex::mm(PtrId idxPtrNum)
     {
-
+	assert(0);
+	return 0;
     }
     
-    size_t YIndex::dim() const
+    SizeT YIndex::dim() const
     {
 	return mRange->dim();
     }
     
-    size_t YIndex::getStepSize(size_t n) const
+    SizeT YIndex::getStepSize(SizeT n) const
     {
-	
+	assert(0);
+	return 0;
     }
     
     String YIndex::stringMeta() const
@@ -64,9 +71,9 @@ namespace CNORXZ
 	String out = "[";
 	auto it = mIs.begin();
 	for(; it != mIs.end()-1; ++it){
-	    out += it->stringMeta() + ","
+	    out += (*it)->stringMeta() + ",";
 	}
-	out += it->stringMeta() + "]"
+	out += (*it)->stringMeta() + "]";
 	return out;
     }
     
@@ -74,7 +81,7 @@ namespace CNORXZ
     {
 	//this->sync();
 	Vector<DType> v(mIs.size());
-	std::transform(mIs.begin(), mIs.end(), v.begin(), [](auto& x) { return x->meta() });
+	std::transform(mIs.begin(), mIs.end(), v.begin(), [](auto& x) { return x->meta(); });
 	return DType(v);
     }
     
@@ -82,20 +89,22 @@ namespace CNORXZ
     {
 	auto& v = std::any_cast<const Vector<DType>&>(meta.get());
 	assert(v.size() == mIs.size());
-	for(size_t i = 0; i != mIs.size()){
+	for(SizeT i = 0; i != mIs.size(); ++i){
 	    mIs[i]->at(v[i]);
 	}
 	return *this;
     }
     
-    DynamicExpression YIndex::ifor(size_t step, DynamicExpression ex) const
+    DExpr YIndex::ifor(SizeT step, DExpr ex) const
     {
-
+	assert(0);
+	return DExpr();
     }
     
-    DynamicExpression YIndex::iforh(size_t step, DynamicExpression ex) const
+    DExpr YIndex::iforh(SizeT step, DExpr ex) const
     {
-
+	assert(0);
+	return DExpr();
     }
 
 }