corrections + remove old files + some todos

src/include/ranges/index_base.h

@@ -56,20 +56,9 @@ namespace CNORXZ
 	decltype(auto) xpr(const Sptr<I>& _this) const { return THIS().xpr(_this); }
 
 	RangePtr prange(const IndexInterface& end) const { return THIS().prange(end.THIS()); }
-	/*
-	template <class Index>
-	decltype(auto) formatTo(const Sptr<Index>& ind) const { return ind->formatFrom(THIS()); }
 
-	template <class Index>
-	decltype(auto) formatFrom(const Index& ind) const // yes this is const,
-	// changes only MIndex/YIndex format, in this case we can just copy the pointers to the sub-index instances
-	{ return THIS().formatFrom(ind); }
-	*/
 	decltype(auto) deepFormat() const { return THIS().deepFormat(); }
 	
-	//template <class Index>
-	//decltype(auto) slice(const Sptr<Index>& ind) const { return THIS().slice(ind); }
-	
 	template <class Xpr, class F = NoF>
 	decltype(auto) ifor(const Xpr& xpr, F&& f) const
 	{ return THIS().ifor(xpr,std::forward<F>(f)); }

src/include/ranges/mrange.cc.h

@@ -604,8 +604,20 @@ namespace CNORXZ
     template <class... Ranges>
     MArray<RangePtr> MRange<Ranges...>::sub() const
     {
-	CXZ_ERROR("not implemented (SRange missing!!)"); //!!!
+	// TODO: ZRange (meta and index pos static!)
-	return MArray<RangePtr>();
+	if constexpr(NR == 0) {
+	    return MArray<RangePtr>();
+	}
+	else {
+	    RangePtr sr = SRangeFactory<SizeT,NR>
+		( iter<0,NR>
+		  ( [](auto i) { return i; },
+		    [](auto... x) { return Arr<SizeT,NR> { x... }; } ) ).create();
+	    return MArray<RangePtr>
+		( sr, iter<0,NR>
+		  ( [&](auto i) { return std::get<i>(mRs); },
+		    [](auto... x) { return Vector<RangePtr> ({ x... }); } ) );
+	}
     }
 
     template <class... Ranges>

src/include/ranges/nrange.h

@@ -1,96 +0,0 @@
-
-
-#ifdef include_range_type
-include_range_type(NUL,-2)
-#else
-
-#ifdef __cxz_ranges_header__
-// assert, that this is only used within range_types/header.h
-
-#ifndef __cxz_range_type_null_def__
-#define __cxz_range_type_null_def__
-
-namespace CNORXZ
-{   
-    typedef GenSingleIndex<size_t,SpaceType::NUL,0> NullIndex;
-
-    std::shared_ptr<GenSingleRange<size_t,SpaceType::NUL,0> > nullr();
-    std::shared_ptr<NullIndex> nulli();
-
-    template <>
-    class GenSingleRangeFactory<size_t,SpaceType::NUL,0> : public RangeFactoryBase
-    {
-    public:
-	
-	typedef GenSingleRange<size_t,SpaceType::NUL,0> oType;
-
-	GenSingleRangeFactory();
-	std::shared_ptr<RangeBase> create();
-
-	friend std::shared_ptr<oType> nullr();
-	
-    private:
-	static std::shared_ptr<oType> mRInstance;
-    };
-
-    template <>
-    class GenSingleRange<size_t,SpaceType::NUL,0> : public RangeInterface<NullIndex>
-    {
-    public:
-	typedef RangeBase RB;
-	typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::NUL,0> >::IndexType IndexType;
-	typedef GenSingleRange<size_t,SpaceType::NUL,0> RangeType;
-	typedef size_t MetaType;
-        typedef GenSingleRangeFactory<size_t,SpaceType::NUL,0> FType; 
-	
-	virtual size_t size() const final;
-	virtual size_t dim() const final;
-
-        virtual vector<size_t> typeNum() const final;
-        virtual size_t cmeta(char* target, size_t pos) const final;
-        virtual size_t cmetaSize() const final;
-	virtual std::string stringMeta(size_t pos) const final;
-	virtual vector<char> data() const final;
-
-	virtual SpaceType spaceType() const final;
-        virtual DataHeader dataHeader() const final;
-        
-	size_t get(size_t pos) const;
-	size_t getMeta(size_t metapos) const;
-	
-	virtual IndexType begin() const final;
-	virtual IndexType end() const final;
-	//virtual std::shared_ptr<VIWB> index() const final;
-	
-	friend GenSingleRangeFactory<size_t,SpaceType::NUL,0>;
-
-	static constexpr bool defaultable = true;
-
-	static constexpr size_t ISSTATIC = 1;
-	static constexpr size_t SIZE = 1;
-	static constexpr bool HASMETACONT = false;
-	
-	static GenSingleRangeFactory<size_t,SpaceType::NUL,0> factory()
-	{ return GenSingleRangeFactory<size_t,SpaceType::NUL,0>(); }
-	
-    protected:
-
-	GenSingleRange() = default;
-	GenSingleRange(const GenSingleRange& in) = delete;
-
-	//GenSingleRange(size_t spinNum);
-    };
-
-    typedef GenSingleRange<size_t,SpaceType::NUL,0> NullRange;
-    typedef GenSingleRangeFactory<size_t,SpaceType::NUL,0> NullRF;
-    
-    std::shared_ptr<NullRF> mkNUL(const char* dp, size_t size);
-	
-}
-
-
-#endif // #ifndef __cxz_range_type_null_def__
-
-#endif // #ifdef __cxz_ranges_header__
-
-#endif // #ifdef include_range_type

src/include/ranges/prange.cc.h

@@ -325,6 +325,8 @@ namespace CNORXZ
     RangePtr PRange<RangeT>::extend(const RangePtr& r) const
     {
 	CXZ_ERROR("implement!!!");
+	// if r is PRange of same Range, then just add parts
+	// else derive and add meta of r
 	return nullptr;
     }
 

src/include/ranges/srange.h

@@ -51,13 +51,7 @@ namespace CNORXZ
 
 	RangePtr prange(const SIndex<MetaType,S>& last) const;
 	SizeT deepFormat() const;
-	/*
-	template <class Index>
-	decltype(auto) formatFrom(const Index& ind) const;
 
-	template <class Index>
-	decltype(auto) slice(const Sptr<Index>& ind) const;
-	*/
 	template <class Xpr, class F>
 	decltype(auto) ifor(const Xpr& xpr, F&& f) const;
 

src/include/ranges/xindex.cc.h

@@ -147,69 +147,6 @@ namespace CNORXZ
 	return toVec( mI->deepFormat() );
     }
     
-    /*
-    template <class Index, typename Meta>
-    Vector<XIndexPtr> XIndex<Index,Meta>::pack() const
-    {
-	if constexpr(has_static_sub<Index>::value){
-	    constexpr SizeT D = index_dim<Index>::value;
-	    return iter<0,D>
-		( [&](auto i) { return xindexPtr(std::get<i>(mI->THIS().pack())); },
-		  [](const auto&... e) { return Vector<XIndexPtr>({ e ... }); } );
-	}
-	else if constexpr(has_sub<Index>::value){
-	    return mI->THIS().pack();
-	}
-	else {
-	    return Vector<XIndexPtr>();
-	}
-    }
-
-    template <class Index, typename Meta>
-    Vector<SizeT> XIndex<Index,Meta>::blockSizes() const
-    {
-	if constexpr(has_static_sub<Index>::value){
-	    constexpr SizeT D = index_dim<Index>::value;
-	    const auto& bs = mI->THIS().blockSizes();
-	    return iter<0,D>
-		( [&](auto i) { return std::get<i>(bs); },
-		  [](const auto&... e) { return Vector<SizeT>( { static_cast<SizeT>(e)... } ); } );
-	}
-	else if constexpr(has_sub<Index>::value) {
-	    return mI->THIS().blockSizes();
-	}
-	else {
-	    return Vector<SizeT>();
-	}
-    }
-
-    template <class Index, typename Meta>
-    XIndexPtr XIndex<Index,Meta>::setBlockSizes(const Vector<SizeT>& bs)
-    {
-	if constexpr(has_static_sub<Index>::value){
-	    constexpr SizeT D = index_dim<Index>::value;
-	    CXZ_ASSERT(bs.size() == D,
-		       "got block sizes of wrong dimension: " << bs.size() << " vs " << D);
-	    typedef decltype(mI->THIS().blockSizes()) BT;
-	    Arr<UPos,D> arr;
-	    std::copy_n(bs.begin(), D, arr.begin());
-	    if constexpr(std::is_same<BT,Arr<UPos,D>>::value){
-		mI->THIS().setBlockSizes(arr);
-		return nullptr;
-	    }
-	    else {
-		return xindexPtr(replaceBlockSizes(arr, std::static_pointer_cast<Index>(mI)));
-	    }
-	}
-	else if constexpr(has_sub<Index>::value) {
-	    mI->THIS().setBlockSizes(bs);
-	    return nullptr;
-	}
-	else {
-	    return nullptr;
-	}
-    }
-    */
     template <class Index, typename Meta>
     String XIndex<Index,Meta>::stringMeta() const
     {
@@ -225,7 +162,6 @@ namespace CNORXZ
     template <class Index, typename Meta>
     XIndexBase& XIndex<Index,Meta>::at(const DType& meta)
     {
-	// check!!!
 	mI->at(std::any_cast<const Meta&>(meta.get()));
 	return *this;
     }

src/include/ranges/xindex.h

@@ -41,9 +41,6 @@ namespace CNORXZ
 	virtual UPos stepSize(const IndexId<0>& id) const = 0;
 	virtual RangePtr prange(const XIndexPtr& last) const = 0;
 	virtual Vector<SizeT> deepFormat() const = 0;
-	//virtual Vector<XIndexPtr> pack() const = 0;
-	//virtual Vector<SizeT> format() const = 0;
-	//virtual XIndexPtr setBlockSizes(const Vector<SizeT>& bs) = 0;
 
 	virtual String stringMeta() const = 0;
 	virtual DType meta() const = 0;
@@ -97,9 +94,6 @@ namespace CNORXZ
 	virtual UPos stepSize(const IndexId<0>& id) const override final;
 	virtual RangePtr prange(const XIndexPtr& last) const override final;
 	virtual Vector<SizeT> deepFormat() const override final;
-	//virtual Vector<XIndexPtr> pack() const override final;
-	//virtual Vector<SizeT> format() const override final;
-	//virtual XIndexPtr setBlockSizes(const Vector<SizeT>& bs) override final;
 
 	virtual String stringMeta() const override final;
 	virtual DType meta() const override final;

src/include/xpr/pos_type.h

@@ -179,7 +179,7 @@ namespace CNORXZ
 	constexpr decltype(auto) operator<<(const PosT& a) const;
     };
 
-    // treat as scalar pos!!!
+    // treat as scalar pos!
     class DPos : public ObjHandle<VPosBase>
     {
     public:

src/include/xpr/xfor.h

@@ -1,567 +0,0 @@
-
-#ifndef __cxz_xfor_h__
-#define __cxz_xfor_h__
-
-#include <omp.h>
-
-#include "base/base.h"
-#include "for_type.h"
-#include "for_utils.h"
-#include "exttype.h"
-
-namespace CNORXZ
-{
-    // 'HIDDEN FOR' CLASS for nested for loops in contractions a.s.o.
-    // (NO COUNTING OF MASTER POSITION !!!!!)
-
-
-    /*
-    template <ForType FT = ForType::DEFAULT>
-    struct PosForward
-    {
-	static inline size_t valuex(size_t last, size_t step, size_t pos)
-	{
-	    return last + pos * step;
-	}
-
-	static inline size_t value(size_t last, size_t max, size_t pos)
-	{
-	    return last * max + pos;
-	}
-    };
-
-    template <>
-    struct PosForward<ForType::HIDDEN>
-    {
-	static inline size_t valuex(size_t last, size_t step, size_t pos)
-	{
-	    return last;
-	}
-
-	static inline size_t value(size_t last, size_t max, size_t pos)
-	{
-	    return last;
-	}
-    };
-
-    template <class IndexClass, class Expr>
-    class SubExpr : public ExpressionBase
-    {
-    private:
-	SubExpr() = default;
-
-	const IndexClass* mIndPtr;
-	PtrId mSIPtr;
-	size_t mSPos;
-	size_t mMax;
-
-        Expr mExpr;
-	typedef decltype(mkExt(0).extend(mExpr.rootSteps())) ExtType;
-	ExtType mExt;
-
-        const Vector<SizeT>* mSubSet;
-        
-        mutable ExtType mRootSteps;
-
-    public:
-	typedef ExpressionBase EB;
-	
-	static constexpr size_t LAYER = Expr::LAYER + 1;
-	static constexpr size_t SIZE = Expr::SIZE + 1;
-	//static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
-
-	DEFAULT_MEMBERS_X(SubExpr);
-	
-	SubExpr(const Sptr<IndexClass>& indPtr,
-		std::intptr_t siptr,
-                const vector<size_t>* subset, Expr expr);
-
-	SubExpr(const IndexClass* indPtr, std::intptr_t siptr,
-                const vector<size_t>* subset, Expr expr);
-
-	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;
-
-        DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
-        DExt dExtension() const override final;
-
-        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
-	auto extension() const -> ExtType;
-    };
-
-    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
-    {
-    private:
-	For() = default;
-		
-	typedef typename IndexClass::RangeType RangeType;
-	const IndexClass* mIndPtr;
-	size_t mSPos;
-	size_t mMax;
-	size_t mStep;
-
-	Expr mExpr;
-	typedef decltype(mExpr.rootSteps()) ExtType;
-	ExtType mExt;
-
-        mutable ExtType mRootSteps;
-        
-    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;
-
-	DEFAULT_MEMBERS(For);
-	
-	For(const Sptr<IndexClass>& indPtr,
-	    size_t step, Expr expr);
-
-	For(const IndexClass* indPtr,
-	    size_t step, Expr expr);
-
-	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;
-        
-        DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
-        DExt dExtension() const override final;
-
-        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
-	auto extension() const -> ExtType;
-
-    };
-
-    class DynamicExpression : public ExpressionBase
-    {
-    private:
-
-	size_t mThreadId = 0;
-	Sptr<ExpressionBase> mNext;
-
-	DynamicExpression() : mThreadId(omp_get_thread_num()) {}
-    public:
-	
-	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()),
-	    mNext( (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
-		   in.mNext : in.mNext->deepCopy()) {}
-	DynamicExpression(DynamicExpression&& in) :
-	    mThreadId(omp_get_thread_num()),
-	    mNext( (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
-		   in.mNext : in.mNext->deepCopy()) {}
-	DynamicExpression& operator=(const DynamicExpression& in)
-	{
-	    mThreadId = omp_get_thread_num();
-	    mNext = (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
-		in.mNext : in.mNext->deepCopy();
-	    return *this;
-	}
-	
-	DynamicExpression& operator=(DynamicExpression&& in)
-	{
-	    mThreadId = omp_get_thread_num();
-	    mNext = (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
-		in.mNext : in.mNext->deepCopy();
-	    return *this;
-	}
-	
-	DynamicExpression(const Sptr<ExpressionBase>& next) :
-	    mNext(next)
-	{}
-
-        template <class Expr>
-        DynamicExpression(const ExpressionBase& next) :
-	    mNext(std::make_shared<Expr>(next))
-	{}
-
-        template <class Expr>
-        DynamicExpression(Expr ex) : mNext( std::make_shared<Expr>(ex) ) {}
-        
-	virtual Sptr<ExpressionBase> deepCopy() const override final
-	{
-	    return std::make_shared<DynamicExpression>(*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;
-
-        inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
-        inline DExt dExtension() const override final;
-
-        inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return DExtT(dRootSteps(iPtrNum)); }
-        inline DExtT extension() const { return DExtT(dExtension()); }
-
-    };
-
-    */
-} 
-
-/* ========================= *
- * ---   TEMPLATE CODE   --- *
- * ========================= */
-
-
-namespace CNORXZ
-{
-    
-    /*****************
-     *     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) :
-	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, 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 )))
-    {
-	//VCHECK(mMax);
-	//VCHECK(DIV);
-	//assert(mMax % DIV == 0);
-	assert(mIndPtr != nullptr);
-    }
-
-    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, 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,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, 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,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, 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, size_t DIV>
-    auto For<IndexClass,Expr,FT,DIV>::extension() const
-	-> ExtType
-    {
-	return mExt;
-    }
-
-    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);
-        //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, 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, 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,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) :
-	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, 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, 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, size_t DIV>
-    inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast,
-						    ExtType last)
-    {
-        CHECK;
-	typedef typename IndexClass::RangeType RangeType;
-        int pos = 0;
-        size_t mnpos = 0;
-        ExtType npos;
-#pragma omp parallel shared(mExpr) private(pos,mnpos,npos)
-        {
-            auto expr = mExpr;
-#pragma omp for nowait
-            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);
-            }
-        }
-    }
-
-    template <class IndexClass, class Expr, size_t DIV>
-    inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast)
-    {
-        CHECK;
-	ExtType last = rootSteps();
-	last.zero();
-        int pos = 0;
-        size_t mnpos = 0;
-        ExtType npos = rootSteps();
-	npos.zero();
-#pragma omp parallel shared(mExpr) private(pos,mnpos,npos)
-        {
-            auto expr = mExpr;
-#pragma omp for nowait
-            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);
-            }
-        }
-    }
-    
-    
-    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, size_t DIV>
-    auto PFor<IndexClass,Expr,DIV>::extension() const
-	-> ExtType
-    {
-	return mExt;
-    }
-
-    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);
-        //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, 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),
-	//					    sizeof(ExtType)/sizeof(size_t));
-    }
-    */
-    
-    /****************
-     *   SubExpr    *
-     ****************/
-    /*
-    template <class IndexClass, class Expr>
-    SubExpr<IndexClass,Expr>::SubExpr(const Sptr<IndexClass>& indPtr,
-				      std::intptr_t siptr,
-                                      const vector<size_t>* subset, Expr expr) :
-	mIndPtr(indPtr.get()), mSIPtr(siptr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
-        mExpr(expr),
-	mExt( mkExt(0).extend( mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )) ) ),
-        mSubSet(subset)
-    {
-	assert(mIndPtr != nullptr);
-    }
-
-    template <class IndexClass, class Expr>
-    SubExpr<IndexClass,Expr>::SubExpr(const IndexClass* indPtr, std::intptr_t siptr,
-                                      const vector<size_t>* subset, Expr expr) :
-	mIndPtr(indPtr), mSIPtr(siptr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
-        mExpr(expr),
-	mExt( mkExt(0).extend( mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )) ) ),
-        mSubSet(subset)
-    {
-	assert(mIndPtr != nullptr);
-    }
-
-    template <class IndexClass, class Expr>
-    inline void SubExpr<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 SubExpr<IndexClass,Expr>::operator()(size_t mlast,
-                                                     ExtType last)
-    {
-        const size_t pos = (*mSubSet)[last.val()];
-        const size_t mnpos = mlast;
-        const ExtType npos = last + mExt*pos;
-        mExpr(mnpos, getX<1>( npos ));
-    }
-
-    template <class IndexClass, class Expr>
-    inline void SubExpr<IndexClass,Expr>::operator()(size_t mlast)
-    {
-	ExtType last = rootSteps();
-	last.zero();
-        const size_t pos = (*mSubSet)[last.val()];
-        const size_t mnpos = mlast;
-        const ExtType npos = last + mExt*pos;
-        mExpr(mnpos, getX<1>( npos ));
-    }
-    
-    
-    template <class IndexClass, class Expr>
-    auto SubExpr<IndexClass,Expr>::rootSteps(std::intptr_t iPtrNum) const
-	-> ExtType
-    {
-	return mkExt(iPtrNum == mSIPtr ? 1 : 0).extend(mExpr.rootSteps(iPtrNum));
-    }
-
-    template <class IndexClass, class Expr>
-    auto SubExpr<IndexClass,Expr>::extension() const
-	-> ExtType
-    {
-	return mExt;
-    }
-
-    template <class IndexClass, class Expr>
-    DExt SubExpr<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 SubExpr<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));
-    }
-    */
-    /***************************
-     *   DynamicExpression   *
-     ***************************/
-    /*
-    inline void DynamicExpression::operator()(size_t mlast, DExt last)
-    {
-	(*mNext)(mlast,last);
-    }
-
-    inline void DynamicExpression::operator()(size_t mlast)
-    {
-	(*mNext)(mlast);
-    }
-
-    inline DExt DynamicExpression::dRootSteps(std::intptr_t iPtrNum) const
-    {
-        return mNext->dRootSteps(iPtrNum);
-    }
-
-    inline DExt DynamicExpression::dExtension() const
-    {
-        return mNext->dExtension();
-    }
-
-    */
-} // namespace CNORXZInternal
-
-#endif

src/lib/ranges/nrange.cc

@@ -1,148 +0,0 @@
-
-#include "ranges/rheader.h"
-#include "ranges/x_to_string.h"
-#include "ranges/ranges_header.cc.h"
-
-namespace CNORXZ
-{
-    std::shared_ptr<NullRF> mkNUL(const char* dp, size_t size)
-    {
-	return std::make_shared<NullRF>();
-    }
-	
-    /********************
-     *   GenSingleRange    *
-     ********************/
-
-    std::shared_ptr<GenSingleRange<size_t,SpaceType::NUL,0>>
-    GenSingleRangeFactory<size_t,SpaceType::NUL,0>::mRInstance = nullptr;
-    
-    std::shared_ptr<NullRange> nullr()
-    {
-	static NullRF nrf; // just that mRInstance is initialized
-	static auto nr = std::dynamic_pointer_cast<NullRange>( nrf.create() );
-	return NullRF::mRInstance;
-    }
-
-    std::shared_ptr<NullIndex> nulli()
-    {
-	return std::make_shared<NullIndex>(nullr());
-    }
-
-    GenSingleRangeFactory<size_t,SpaceType::NUL,0>::GenSingleRangeFactory()
-    {
-	// Singleton
-	if(not mRInstance){
-	    if(not mProd){
-		mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::NUL,0>() );
-		setSelf();
-	    }
-	    mRInstance = std::dynamic_pointer_cast<NullRange>( mProd );
-	} else {
-	    mProd = mRInstance;
-	}
-    }
-
-    std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::NUL,0>::create()
-    {
-	return mProd;
-    }
-    
-    /********************
-     *   GenSingleRange    *
-     ********************/
-    
-    size_t GenSingleRange<size_t,SpaceType::NUL,0>::get(size_t pos) const
-    {
-	return 0;
-    }
-    
-    size_t GenSingleRange<size_t,SpaceType::NUL,0>::getMeta(size_t metapos) const
-    {
-	return 0;
-    }
-    
-    size_t GenSingleRange<size_t,SpaceType::NUL,0>::size() const
-    {
-	return 1;
-    }
-    
-    size_t GenSingleRange<size_t,SpaceType::NUL,0>::dim() const
-    {
-	return 1;
-    }
-
-    SpaceType GenSingleRange<size_t,SpaceType::NUL,0>::spaceType() const
-    {
-	return SpaceType::NUL;
-    }
-
-    vector<size_t> GenSingleRange<size_t,SpaceType::NUL,0>::typeNum() const
-    {
-        return {NumTypeMap<size_t>::num()};
-    }
-    
-    size_t GenSingleRange<size_t,SpaceType::NUL,0>::cmeta(char* target, size_t pos) const
-    {
-        *reinterpret_cast<size_t*>(target) = 0;
-        return sizeof(size_t);
-    }
-
-    size_t GenSingleRange<size_t,SpaceType::NUL,0>::cmetaSize() const
-    {
-        return sizeof(size_t);
-    }
-
-    std::string GenSingleRange<size_t,SpaceType::NUL,0>::stringMeta(size_t pos) const
-    {
-	return std::to_string(get(pos));
-    }
-
-    vector<char> GenSingleRange<size_t,SpaceType::NUL,0>::data() const
-    {
-	DataHeader h = dataHeader(); 
-	vector<char> out;
-	out.reserve(h.metaSize + sizeof(DataHeader));
-	char* hcp = reinterpret_cast<char*>(&h);
-	out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
-	return out;
-    }
-
-    DataHeader GenSingleRange<size_t,SpaceType::NUL,0>::dataHeader() const
-    {
-	DataHeader h;
-	h.spaceType = static_cast<int>( SpaceType::NUL );
-	h.metaSize = 0;
-	h.multiple = 0;
-        return h;
-    }
-   
-    typename GenSingleRange<size_t,SpaceType::NUL,0>::IndexType GenSingleRange<size_t,SpaceType::NUL,0>::begin() const
-    {
-	GenSingleIndex<size_t,SpaceType::NUL,0> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
-			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
-	i = 0;
-	return i;
-    }
-    
-    typename GenSingleRange<size_t,SpaceType::NUL,0>::IndexType GenSingleRange<size_t,SpaceType::NUL,0>::end() const
-    {
-	GenSingleIndex<size_t,SpaceType::NUL,0> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
-			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
-	i = size();
-	return i;
-    }
-
-    // put this in the interface class !!!
-    /*
-    std::shared_ptr<VIWB> GenSingleRange<size_t,SpaceType::NUL,0>::index() const
-    {
-	typedef IndexWrapper<IndexType> IW;
-	return std::make_shared<IW>
-            ( std::make_shared<IndexType>
-	      ( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
-		( std::shared_ptr<RangeBase>( RB::mThis ) ) ) );
-    }
-    */
-}
-

src/tests/operation_unit_test.cc

@@ -6,6 +6,7 @@
 
 #include "ranges/ranges.h"
 #include "operation/operation.h"
+#include "array/array.h"
 #include "test_numbers.h"
 
 namespace

src/tests/range_unit_test.cc

@@ -6,6 +6,7 @@
 
 //#include "cnorxz.h"
 #include "ranges/ranges.h"
+#include "array/array.h"
 
 namespace
 {