From bd6f15156b9dfa2c1ff7a9ca2622ed70489612fb Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 15 Jun 2023 00:41:17 +0200
Subject: [PATCH] WIP: fix test errors...

---
 src/include/operation/extensions/reg.cc.h | 41 ++++++++++++-----------
 src/include/operation/extensions/reg.h    |  7 ++++
 src/include/xpr/pos_type.cc.h             | 39 +++++++++++++++++++--
 src/include/xpr/pos_type.h                | 17 +++++++---
 src/tests/operation_unit_test.cc          |  8 ++---
 5 files changed, 81 insertions(+), 31 deletions(-)

diff --git a/src/include/operation/extensions/reg.cc.h b/src/include/operation/extensions/reg.cc.h
index 85dd00e..3ff3596 100644
--- a/src/include/operation/extensions/reg.cc.h
+++ b/src/include/operation/extensions/reg.cc.h
@@ -33,6 +33,7 @@ namespace CNORXZ
     {
 	constexpr SizeT N = epos_size<EPosT>::value;
 	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);
 	}
@@ -117,32 +118,32 @@ namespace CNORXZ
     constexpr decltype(auto)
     PlusCC<T,U,N>::eval(const Consecutive<T,N>& a, const Consecutive<U,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x + y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x + y; }, a, b );
     }
 
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto)
     PlusCC<T,U,N>::aeval(Consecutive<T,N>& o, const Consecutive<U,N>& a)
     {
-	return consecFuncA( [](auto& x, const auto& y) { return x += y; }, o, a );
+	return consecFuncA<N>( [](auto& x, const auto& y) { return x += y; }, o, a );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) PlusCX<T,X,N>::eval(const Consecutive<T,N>& a, const X& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x + y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x + y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) PlusCX<T,X,N>::eval(const X& a, const Consecutive<T,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x + y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x + y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) PlusCX<T,X,N>::aeval(Consecutive<T,N>& o, const X& a)
     {
-	return consecFuncA( [](auto& x, const auto& y) { return x += y; }, o, a );
+	return consecFuncA<N>( [](auto& x, const auto& y) { return x += y; }, o, a );
     }
 
     /*******************************
@@ -152,31 +153,31 @@ namespace CNORXZ
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto) MinusCC<T,U,N>::eval(const Consecutive<T,N>& a, const Consecutive<U,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x - y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x - y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) MinusCX<T,X,N>::eval(const Consecutive<T,N>& a, const X& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x - y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x - y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) MinusCX<T,X,N>::eval(const X& a, const Consecutive<T,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x - y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x - y; }, a, b );
     }
 
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto) MinusCC<T,U,N>::aeval(Consecutive<T,N>& o, const Consecutive<U,N>& a)
     {
-	return consecFuncA( [](auto& x, const auto& y) { return x -= y; }, o, a );
+	return consecFuncA<N>( [](auto& x, const auto& y) { return x -= y; }, o, a );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) MinusCX<T,X,N>::aeval(Consecutive<T,N>& o, const X& a)
     {
-	return consecFuncA( [](auto& x, const auto& y) { return x -= y; }, o, a );
+	return consecFuncA<N>( [](auto& x, const auto& y) { return x -= y; }, o, a );
     }
 
     /***********************************
@@ -186,31 +187,31 @@ namespace CNORXZ
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto) MultipliesCC<T,U,N>::eval(const Consecutive<T,N>& a, const Consecutive<U,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x * y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x * y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) MultipliesCX<T,X,N>::eval(const Consecutive<T,N>& a, const X& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x * y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x * y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) MultipliesCX<T,X,N>::eval(const X& a, const Consecutive<T,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x * y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x * y; }, a, b );
     }
 
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto) MultipliesCC<T,U,N>::aeval(Consecutive<T,N>& o, const Consecutive<U,N>& a)
     {
-	return consecFuncA( [](const auto& x, const auto& y) { return x *= y; }, o, a );
+	return consecFuncA<N>( [](const auto& x, const auto& y) { return x *= y; }, o, a );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) MultipliesCX<T,X,N>::aeval(Consecutive<T,N>& o, const X& a)
     {
-	return consecFuncA( [](const auto& x, const auto& y) { return x *= y; }, o, a );
+	return consecFuncA<N>( [](const auto& x, const auto& y) { return x *= y; }, o, a );
     }
 
     /*********************************
@@ -220,31 +221,31 @@ namespace CNORXZ
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto) DividesCC<T,U,N>::eval(const Consecutive<T,N>& a, const Consecutive<U,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x / y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x / y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) DividesCX<T,X,N>::eval(const Consecutive<T,N>& a, const X& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x / y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x / y; }, a, b );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) DividesCX<T,X,N>::eval(const X& a, const Consecutive<T,N>& b)
     {
-	return consecFunc( [](const auto& x, const auto& y) { return x / y; }, a, b );
+	return consecFunc<N>( [](const auto& x, const auto& y) { return x / y; }, a, b );
     }
 
     template <typename T, typename U, SizeT N>
     constexpr decltype(auto) DividesCC<T,U,N>::aeval(Consecutive<T,N>& o, const Consecutive<U,N>& a)
     {
-	return consecFuncA( [](const auto& x, const auto& y) { return x /= y; }, o, a );
+	return consecFuncA<N>( [](const auto& x, const auto& y) { return x /= y; }, o, a );
     }
 
     template <typename T, typename X, SizeT N>
     constexpr decltype(auto) DividesCX<T,X,N>::aeval(Consecutive<T,N>& o, const X& a)
     {
-	return consecFuncA( [](const auto& x, const auto& y) { return x /= y; }, o, a );
+	return consecFuncA<N>( [](const auto& x, const auto& y) { return x /= y; }, o, a );
     }
 }
 
diff --git a/src/include/operation/extensions/reg.h b/src/include/operation/extensions/reg.h
index f03b848..2421301 100644
--- a/src/include/operation/extensions/reg.h
+++ b/src/include/operation/extensions/reg.h
@@ -13,6 +13,13 @@ namespace CNORXZ
     struct Consecutive
     {
 	T mD[N];
+	Consecutive& operator=(const Consecutive& a)
+	{
+	    iter<0,N>([&](auto i) { mD[i] = a.mD[i]; VCHECK(mD[i]); }, NoF{} );
+	    return *this;
+	}
+
+	Consecutive& operator=(Consecutive&& a) = delete;
     };
 
     template <typename T>
diff --git a/src/include/xpr/pos_type.cc.h b/src/include/xpr/pos_type.cc.h
index 4370e70..d11f4da 100644
--- a/src/include/xpr/pos_type.cc.h
+++ b/src/include/xpr/pos_type.cc.h
@@ -586,6 +586,37 @@ namespace CNORXZ
 	mP(os...)
     {}
 
+    template <class BPosT, class... OPosTs>
+    template <class PosT>
+    constexpr decltype(auto) EPos<BPosT,OPosTs...>::operator+(const PosT& a) const
+    {
+	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...); } );
+    }
+    
+    template <class BPosT, class... OPosTs>
+    template <class PosT>
+    constexpr decltype(auto) EPos<BPosT,OPosTs...>::operator*(const PosT& a) const
+    {
+	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...); } );
+    }
+
+    template <class BPosT, class... OPosTs>
+    template <class PosT>
+    constexpr decltype(auto) EPos<BPosT,OPosTs...>::operator()(const PosT& a) const
+    {
+	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...); } );
+    }
+
+
     template <class BPosT, class... OPosTs>
     constexpr decltype(auto) EPos<BPosT,OPosTs...>::val() const
     {
@@ -635,11 +666,13 @@ namespace CNORXZ
 	return mkiEPos(a, b, std::make_index_sequence<N>{});
     }
 
-    template <class BPosT, class NPosT, class OPosT, SizeT N>
-    decltype(auto) MkEPos<MPos<BPosT,NPosT>,OPosT,N>::mk(const MPos<BPosT,NPosT>& a, const OPosT& b)
+    template <class BPosT, class NPosT, class OPosT, class ONPosT, SizeT N>
+    decltype(auto) MkEPos<MPos<BPosT,NPosT>,MPos<OPosT,ONPosT>,N>::mk(const MPos<BPosT,NPosT>& a, const MPos<OPosT,ONPosT>& b)
     {
 	const BPosT& ax = static_cast<const BPosT&>(a);
-	return MPos<decltype(mkEPos<N>(ax,b)),NPosT>(mkEPos<N>(ax,b), a.next());
+	const OPosT& bx = static_cast<const OPosT&>(b);
+	return MPos<decltype(mkEPos<N>(ax,bx)),decltype(mkEPos<N>(a.next(),b.next()))>
+	    (mkEPos<N>(ax,bx), mkEPos<N>(a.next(),b.next()));
     }
 
     template <SizeT N, class BPosT, class OPosT>
diff --git a/src/include/xpr/pos_type.h b/src/include/xpr/pos_type.h
index c345a53..357eb4e 100644
--- a/src/include/xpr/pos_type.h
+++ b/src/include/xpr/pos_type.h
@@ -276,6 +276,15 @@ namespace CNORXZ
 	constexpr EPos(const BPosT& b, const OPosTs&... os);
 	constexpr EPos(BPosT&& b, OPosTs&&... os);
 
+	template <class PosT>
+	constexpr decltype(auto) operator+(const PosT& a) const;
+
+	template <class PosT>
+	constexpr decltype(auto) operator*(const PosT& a) const;
+
+	template <class PosT>
+	constexpr decltype(auto) operator()(const PosT& a) const;
+
 	constexpr decltype(auto) val() const;
 	constexpr decltype(auto) next() const;
 
@@ -345,10 +354,10 @@ namespace CNORXZ
 	static decltype(auto) mk(const BPosT& a, const OPosT& b);
     };
 
-    template <class BPosT, class NPosT, class OPosT, SizeT N>
-    struct MkEPos<MPos<BPosT,NPosT>,OPosT,N>
+    template <class BPosT, class NPosT, class OPosT, class ONPosT, SizeT N>
+    struct MkEPos<MPos<BPosT,NPosT>,MPos<OPosT,ONPosT>,N>
     {
-	static decltype(auto) mk(const MPos<BPosT,NPosT>& a, const OPosT& b);
+	static decltype(auto) mk(const MPos<BPosT,NPosT>& a, const MPos<OPosT,ONPosT>& b);
     };
 
     template <SizeT N, class BPosT, class OPosT>
@@ -406,7 +415,7 @@ namespace CNORXZ
     template <class BPosT, class NPosT>
     struct epos_size<MPos<BPosT,NPosT>>
     {
-	static constexpr SizeT value = epos_size<BPosT>::value * epos_size<NPosT>::value;
+	static constexpr SizeT value = epos_size<BPosT>::value;
     };
 
     template <class BPosT, class... OPosTs>
diff --git a/src/tests/operation_unit_test.cc b/src/tests/operation_unit_test.cc
index cc480db..2167c3d 100644
--- a/src/tests/operation_unit_test.cc
+++ b/src/tests/operation_unit_test.cc
@@ -56,8 +56,8 @@ namespace
 	    SizeT off = 20;
 	    mData1 = Numbers::get(off, mSize1);
 	    mData2 = Numbers::get(off += mSize1 , mSize2);
-	    mData11 = Numbers::get(off += mSize2, mSize1*mSize1);
-	    mData12 = Numbers::get(off += mSize1*mSize1, mSize1*mSize2);
+	    mData11 = Numbers::get(off += mSize2, mSize1*mSize2);
+	    mData12 = Numbers::get(off += mSize1*mSize2, mSize1*mSize2);
 	    auto cr1 = CRangeFactory(mSize1).create();
 	    auto cr2 = CRangeFactory(mSize2).create();
 	    mCI1i = std::make_shared<CIndex>(cr1);
@@ -108,8 +108,8 @@ namespace
 	    SizeT off = 20;
 	    mData1 = Numbers::get(off, mSize1);
 	    mData2 = Numbers::get(off += mSize1 , mSize2);
-	    mData11 = Numbers::get(off += mSize2, mSize1*mSize1);
-	    mData12 = Numbers::get(off += mSize1*mSize1, mSize1*mSize2);
+	    mData11 = Numbers::get(off += mSize2, mSize1*mSize2);
+	    mData12 = Numbers::get(off += mSize1*mSize2, mSize1*mSize2);
 	    auto cr1 = CRangeFactory(mSize1).create();
 	    auto cr2 = CRangeFactory(mSize2).create();
 	    mCI1i = std::make_shared<CIndex>(cr1);