various fixes regarding usage of Consecutive

src/include/operation/extensions/reg.cc.h

@@ -21,7 +21,7 @@ namespace CNORXZ
 	constexpr SizeT N = epos_size<EPosT>::value;
 	static_assert(is_epos_type<EPosT>::value, "got non-epos-type");
 	if constexpr(pos_type_is_consecutive<EPosT>::value){
-	    return *reinterpret_cast<const Consecutive<T,N>*>(d);
+	    return *reinterpret_cast<const Consecutive<T,N>*>(d+pos.scal().val());
 	}
 	else {
 	    return vregi(d, pos, std::make_index_sequence<N>{});
@@ -35,7 +35,7 @@ namespace CNORXZ
 	static_assert(is_epos_type<EPosT>::value, "got non-epos-type");
 	static_assert(pos_type_is_consecutive<EPosT>::value, "no write access for non-consecutive");
 	if constexpr(pos_type_is_consecutive<EPosT>::value){
-	    return *reinterpret_cast<Consecutive<T,N>*>(d);
+	    return *reinterpret_cast<Consecutive<T,N>*>(d+pos.scal().val());
 	}
 	else {
 	    return vregi(d, pos, std::make_index_sequence<N>{});

src/include/ranges/crange.cc.h

@@ -8,10 +8,15 @@
 namespace CNORXZ
 {
     template <SizeT I>
-    UPos CIndex::stepSize(const IndexId<I>& id) const
+    decltype(auto) CIndex::stepSize(const IndexId<I>& id) const
     {
+	if constexpr(I != 0){
+	    return SPos<0>();
+	}
+	else {
 	    return UPos(id == this->id() ? 1 : 0);
 	}
+    }
 
     template <class Index>
     decltype(auto) CIndex::reformat(const Sptr<Index>& ind) const

src/include/ranges/crange.h

@@ -40,7 +40,7 @@ namespace CNORXZ
 	Sptr<RangeType> range() const;
 
 	template <SizeT I>
-	UPos stepSize(const IndexId<I>& id) const;
+	decltype(auto) stepSize(const IndexId<I>& id) const;
 	
 	String stringMeta() const;
 	SizeT meta() const;

src/include/ranges/lindex.cc.h

@@ -22,7 +22,7 @@ namespace CNORXZ
     template <SizeT I>
     decltype(auto) LIndex<Index,L>::stepSize(const IndexId<I>& id) const
     {
-	if constexpr(L == 0 or I == 0){
+	if constexpr(L == 0 and I == 0){
 	    return UPos(mI->id() == id ? 1 : 0);
 	}
 	else {
@@ -35,6 +35,13 @@ namespace CNORXZ
 	}
     }
 
+    template <class Index, SizeT L>
+    template <class Xpr, class F>
+    decltype(auto) LIndex<Index,L>::ifor(const Xpr& xpr, F&& f) const
+    {
+	return For<L,Xpr,F>(this->pmax().val(), this->id(), xpr, std::forward<F>(f));
+    }
+    
     template <class Index, SizeT L, class I1>
     decltype(auto) operator*(const Sptr<LIndex<Index,L>>& a, const Sptr<I1>& b)
     {

src/include/ranges/lindex.h

@@ -25,6 +25,9 @@ namespace CNORXZ
 	template <SizeT I>
 	decltype(auto) stepSize(const IndexId<I>& id) const;
 
+	template <class Xpr, class F>
+	decltype(auto) ifor(const Xpr& xpr, F&& f) const;
+
     private:
 	Sptr<Index> mI;
     };

src/include/ranges/mrange.cc.h

@@ -506,9 +506,9 @@ namespace CNORXZ
     }
 
     template <class FormatT, class... Indices>
-    constexpr decltype(auto) gmindexPtr(const FormatT& bs, const Sptr<Indices>&... is)
+    constexpr decltype(auto) gmindexPtr(const FormatT& bs, const SPack<Indices...>& pack)
     {
-	return std::make_shared<GMIndex<FormatT,Indices...>>(bs, is...);
+	return std::make_shared<GMIndex<FormatT,Indices...>>(bs, pack);
     }    
     
     template <class I1, class FormatT, class... Indices>

src/include/ranges/mrange.h

@@ -147,7 +147,7 @@ namespace CNORXZ
     constexpr decltype(auto) mindexPtr(const SPack<Indices...>& pack);
 
     template <class FormatT, class... Indices>
-    constexpr decltype(auto) gmindexPtr(const FormatT& bs, const Sptr<Indices>&... is);
+    constexpr decltype(auto) gmindexPtr(const FormatT& bs, const SPack<Indices...>& pack);
     
     template <class I1, class FormatT, class... Indices>
     decltype(auto) operator*(const Sptr<GMIndex<FormatT,Indices...>>& a, const Sptr<I1>& b);

src/include/ranges/urange.cc.h

@@ -140,10 +140,15 @@ namespace CNORXZ
 
     template <typename MetaType>
     template <SizeT I>
-    UPos UIndex<MetaType>::stepSize(const IndexId<I>& id) const
+    decltype(auto) UIndex<MetaType>::stepSize(const IndexId<I>& id) const
     {
+	if constexpr(I != 0){
+	    return SPos<0>();
+	}
+	else {
 	    return UPos(id == this->id() ? 1 : 0);
 	}
+    }
 
     template <typename MetaType>
     template <class Index>

src/include/ranges/urange.h

@@ -48,7 +48,7 @@ namespace CNORXZ
 	Sptr<RangeType> range() const;
 
 	template <SizeT I>
-	UPos stepSize(const IndexId<I>& id) const;
+	decltype(auto) stepSize(const IndexId<I>& id) const;
 
 	String stringMeta() const;
 	const MetaT& meta() const;

src/include/xpr/index_id.cc.h

@@ -22,7 +22,7 @@ namespace CNORXZ
     template <SizeT J>
     constexpr decltype(auto) IndexId<I>::operator==(const IndexId<J>& a) const
     {
-	if constexpr(I != 0 and J != 0){
+	if constexpr(I != 0 or J != 0){
 	    if constexpr(I == J){
 		CXZ_ASSERT(mId == a.id(),
 			   "got different index ids for equal static index label");

src/include/xpr/pos_type.cc.h

@@ -31,6 +31,13 @@ namespace CNORXZ
 	return SPos<N+N1>();
     }
 
+    template <SizeT N>
+    template <SizeT N1>
+    constexpr auto SPos<N>::operator-(const SPos<N1>& a) const
+    {
+	return SPos<N-N1>();
+    }
+
     template <SizeT N>
     template <SizeT N1>
     constexpr auto SPos<N>::operator*(const SPos<N1>& a) const
@@ -54,14 +61,24 @@ namespace CNORXZ
     template <SizeT N>
     constexpr auto SPos<N>::operator*(const UPos& a) const
     {
+	if constexpr(N == 0){
+	    return SPos<0>();
+	}
+	else {
 	    return UPos(N*a.val());
 	}
+    }
 
     template <SizeT N>
     constexpr auto SPos<N>::operator()(const UPos& a) const
     {
+	if constexpr(N == 0){
+	    return SPos<0>();
+	}
+	else {
 	    return UPos(N*a.val());
 	}
+    }
 
     template <SizeT N>
     template <class PosT>
@@ -603,7 +620,7 @@ namespace CNORXZ
 	return iter<0,sizeof...(OPosTs)>
 	    ( [&](auto i) { return std::get<i>(mP); },
 	      [&](const auto&... e) { return EPos<decltype(BPosT::operator*(a)),OPosTs...>
-		    (BPosT::operator*(a),e...); } );
+		    (BPosT::operator*(a),e*a...); } );
     }
 
     template <class BPosT, class... OPosTs>
@@ -613,7 +630,7 @@ namespace CNORXZ
 	return iter<0,sizeof...(OPosTs)>
 	    ( [&](auto i) { return std::get<i>(mP); },
 	      [&](const auto&... e) { return EPos<decltype(BPosT::operator()(a)),OPosTs...>
-		    (BPosT::operator()(a),e...); } );
+		    (BPosT::operator()(a),e*a...); } );
     }
 
 
@@ -629,11 +646,17 @@ namespace CNORXZ
 	return inext(std::index_sequence_for<OPosTs...>{});
     }
 
+    template <class BPosT, class... OPosTs>
+    constexpr decltype(auto) EPos<BPosT,OPosTs...>::scal() const
+    {
+	return static_cast<const BPosT&>(*this);
+    }
+
     template <class BPosT, class... OPosTs>
     template <SizeT I>
     constexpr decltype(auto) EPos<BPosT,OPosTs...>::get() const
     {
-	return std::get<I>(mP);
+	return scal()+std::get<I>(mP);
     }
 
     template <class BPosT, class... OPosTs>
@@ -644,7 +667,7 @@ namespace CNORXZ
 	    return std::index_sequence<std::get<Is>(mP).val()...>{};
 	}
 	else {
-	    return Arr<SizeT,is.size()> { std::get<Is>(mP).val()... };
+	    return Arr<SizeT,is.size()> { (BPosT::val()+std::get<Is>(mP).val())... };
 	}
     }
 
@@ -653,7 +676,7 @@ namespace CNORXZ
     constexpr decltype(auto) EPos<BPosT,OPosTs...>::inext(std::index_sequence<Is...> is) const
     {
 	typedef EPos<decltype(next()),decltype(std::get<Is>(mP).next())...> OEPosT;
-	return OEPosT(next(), std::get<Is>(mP).next()...);
+	return OEPosT(BPosT::next(), std::get<Is>(mP).next()...);
     }
 
     /*********************************

src/include/xpr/pos_type.h

@@ -21,6 +21,8 @@ namespace CNORXZ
 	template <SizeT N1>
 	constexpr auto operator+(const SPos<N1>& a) const;
 	template <SizeT N1>
+	constexpr auto operator-(const SPos<N1>& a) const;
+	template <SizeT N1>
 	constexpr auto operator*(const SPos<N1>& a) const;
 	template <SizeT N1>
 	constexpr auto operator()(const SPos<N1>& a) const;
@@ -288,6 +290,8 @@ namespace CNORXZ
 	constexpr decltype(auto) val() const;
 	constexpr decltype(auto) next() const;
 
+	constexpr decltype(auto) scal() const;
+
 	template <SizeT I>
 	constexpr decltype(auto) get() const;
     };
@@ -424,6 +428,12 @@ namespace CNORXZ
 	static constexpr bool value = pos_types_consecutive<OPosTs...>::value;
     };
 
+    template <class BPosT, class NPosT>
+    struct pos_type_is_consecutive<MPos<BPosT,NPosT>>
+    {
+	static constexpr bool value = pos_type_is_consecutive<BPosT>::value;
+    };
+
 } // end namespace CNORXZInternal
 
 

src/tests/operation_unit_test.cc

@@ -99,16 +99,17 @@ namespace
     protected:
 
 	typedef MIndex<CIndex,LIndex<CIndex,2>,EIndex<SizeT,4,1>> MCCI1;
+	typedef GMIndex<GMFormat<UPos,UPos,SPos<1>>,CIndex,LIndex<CIndex,2>,EIndex<SizeT,4,1>> MCCI1x;
 	typedef MIndex<LIndex<CIndex,2>,EIndex<SizeT,4,1>,CIndex> MCCI2;
 	
 	OpCont_CR_CR_Test2()
 	{
-	    mSize1 = 12;
+	    mSize1 = 11;
-	    mSize2 = 11;
+	    mSize2 = 12;
 	    SizeT off = 20;
-	    mData1 = Numbers::get(off, mSize1);
+	    //mData1 = Numbers::get(off, mSize1);
-	    mData2 = Numbers::get(off += mSize1 , mSize2);
+	    //mData2 = Numbers::get(off += mSize1 , mSize2);
-	    mData11 = Numbers::get(off += mSize2, mSize1*mSize2);
+	    mData21 = Numbers::get(off += mSize2, mSize1*mSize2);
 	    mData12 = Numbers::get(off += mSize1*mSize2, mSize1*mSize2);
 	    auto cr1 = CRangeFactory(mSize1).create();
 	    auto cr2 = CRangeFactory(mSize2).create();
@@ -116,28 +117,31 @@ namespace
 	    mCI1j = std::make_shared<CIndex>(cr1);
 	    mCI2i = std::make_shared<CIndex>(cr2);
 	    mCI2j = std::make_shared<CIndex>(cr2);
-	    mCC1i1j = mindexPtr(mCI1i*eplex<4,1,2>(mCI1j));
+	    auto ipack1 = mCI1i*eplex<4,1,2>(mCI2j);
-	    mCC1j1i = mindexPtr(eplex<4,1,2>(mCI1j)*mCI1i);
+	    auto iform1 = gmformat(UPos(mCI2j->lmax().val()),UPos(4),SPos<1>());
-	    mOC1i1j.init(mCC1i1j);
+	    mCC1i2j = gmindexPtr( iform1, ipack1 );
-	    mOR1j1i.init(mData11.data(), mCC1j1i);
+	    //mCC1i2j = mindexPtr(mCI1i*eplex<4,1,2>(mCI2j));
-	    mOR1i1j.init(mData12.data(), mCC1i1j);
+	    mCC2j1i = mindexPtr(eplex<4,1,2>(mCI2j)*mCI1i);
+	    mOC1i2j.init(mCC1i2j);
+	    mOR2j1i.init(mData21.data(), mCC2j1i);
+	    mOR1i2j.init(mData12.data(), mCC1i2j);
 	}
 
 	SizeT mSize1;
 	SizeT mSize2;
-	Vector<Double> mData1;
-	Vector<Double> mData2;
-	Vector<Double> mData11;
 	Vector<Double> mData12;
+	Vector<Double> mData21;
+	Vector<Double> mData11_1;
+	Vector<Double> mData11_2;
 	Sptr<CIndex> mCI1i;
 	Sptr<CIndex> mCI1j;
 	Sptr<CIndex> mCI2i;
 	Sptr<CIndex> mCI2j;
-	Sptr<MCCI1> mCC1i1j;
+	Sptr<MCCI1x> mCC1i2j;
-	Sptr<MCCI2> mCC1j1i;
+	Sptr<MCCI2> mCC2j1i;
-	OpCont<double,MCCI1> mOC1i1j;
+	OpCont<double,MCCI1x> mOC1i2j;
-	COpRoot<double,MCCI2> mOR1j1i;
+	COpRoot<double,MCCI2> mOR2j1i;
-	COpRoot<double,MCCI1> mOR1i1j;
+	COpRoot<double,MCCI1x> mOR1i2j;
     };
 
     TEST_F(OpCont_CR_Test, Basics)
@@ -233,24 +237,38 @@ namespace
 
     TEST_F(OpCont_CR_CR_Test2, Assignment)
     {
-	mOC1i1j = mOR1j1i;
+	EXPECT_EQ( mCC2j1i->stepSize( mCC1i2j->pack()[CSizeT<0>{}]->id() ).val(), 1u );
+	EXPECT_EQ( mCC2j1i->stepSize( mCC1i2j->pack()[CSizeT<1>{}]->id() ).val(), 44u );
+	EXPECT_EQ( mCC2j1i->stepSize( mCC1i2j->pack()[CSizeT<2>{}]->id() ).val(), 11u );
+
+	mOC1i2j = mOR2j1i;
+	
 	for(SizeT i = 0; i != mCI1i->pmax().val(); ++i){
-	    for(SizeT j = 0; j != mCI1j->pmax().val(); ++j){
+	    for(SizeT j = 0; j != mCI2j->pmax().val(); ++j){
-		const SizeT jS = mCI1j->pmax().val();
+		const SizeT jS = mCI2j->pmax().val();
 		const SizeT iS = mCI1i->pmax().val();
-		EXPECT_EQ(mOC1i1j.data()[i*jS+j], mOR1j1i.data()[j*iS+i]);
+		EXPECT_EQ(mOC1i2j.data()[i*jS+j], mOR2j1i.data()[j*iS+i]);
 	    }
 	}
+	
     }
 
     TEST_F(OpCont_CR_CR_Test2, Multiply)
     {
-	mOC1i1j = mOR1j1i * mOR1i1j;
+	EXPECT_EQ( mCC2j1i->stepSize( mCC1i2j->pack()[CSizeT<0>{}]->id() ).val(), 1u );
+	EXPECT_EQ( mCC2j1i->stepSize( mCC1i2j->pack()[CSizeT<1>{}]->id() ).val(), 44u );
+	EXPECT_EQ( mCC2j1i->stepSize( mCC1i2j->pack()[CSizeT<2>{}]->id() ).val(), 11u );
+
+	EXPECT_EQ( mCC1i2j->stepSize( mCC1i2j->pack()[CSizeT<0>{}]->id() ).val(), 12u );
+	EXPECT_EQ( mCC1i2j->stepSize( mCC1i2j->pack()[CSizeT<1>{}]->id() ).val(), 4u );
+	EXPECT_EQ( mCC1i2j->stepSize( mCC1i2j->pack()[CSizeT<2>{}]->id() ).val(), 1u );
+
+	mOC1i2j = mOR2j1i * mOR1i2j;
 	for(SizeT i = 0; i != mCI1i->pmax().val(); ++i){
-	    for(SizeT j = 0; j != mCI1j->pmax().val(); ++j){
+	    for(SizeT j = 0; j != mCI2j->pmax().val(); ++j){
-		const SizeT jS = mCI1j->pmax().val();
+		const SizeT jS = mCI2j->pmax().val();
 		const SizeT iS = mCI1i->pmax().val();
-		EXPECT_EQ(mOC1i1j.data()[i*jS+j], mOR1j1i.data()[j*iS+i] * mOR1i1j.data()[i*jS+j]);
+		EXPECT_EQ(mOC1i2j.data()[i*jS+j], mOR2j1i.data()[j*iS+i] * mOR1i2j.data()[i*jS+j]);
 	    }
 	}
     }