From f674407a3859df95e23f6f2276a65e9461b09010 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Fri, 12 Jul 2024 19:16:55 +0200
Subject: [PATCH] WIP: pos type operations

---
 src/include/xpr/pos_type.cc.h | 175 +++++++++++++++++-----------------
 src/include/xpr/pos_type.h    |  49 +++++-----
 2 files changed, 111 insertions(+), 113 deletions(-)

diff --git a/src/include/xpr/pos_type.cc.h b/src/include/xpr/pos_type.cc.h
index b27e0c6..afe5366 100644
--- a/src/include/xpr/pos_type.cc.h
+++ b/src/include/xpr/pos_type.cc.h
@@ -34,13 +34,6 @@ namespace CNORXZ
 	return N;
     }
 
-    template <SizeT N>
-    template <SizeT N1>
-    constexpr decltype(auto) SPos<N>::operator+(const SPos<N1>& a) const
-    {
-	return SPos<N+N1>();
-    }
-
     template <SizeT N>
     template <SizeT N1>
     constexpr decltype(auto) SPos<N>::operator-(const SPos<N1>& a) const
@@ -49,47 +42,50 @@ namespace CNORXZ
     }
 
     template <SizeT N>
-    template <SizeT N1>
-    constexpr decltype(auto) SPos<N>::operator*(const SPos<N1>& a) const
+    template <class PosT>
+    constexpr decltype(auto) SPos<N>::operator+(const PosT& a) const
     {
-	return SPos<N*N1>();
+	if constexpr(is_epos_type<PosT>::value){
+	    a+(*this);
+	}
+	else if constexpr(is_static_pos_type<PosT>::value){
+	    return SPos<N+a.val()>{};
+	}
+	else {
+	    return UPos(N+a.val());
+	}
     }
 
     template <SizeT N>
-    template <SizeT N1>
-    constexpr decltype(auto) SPos<N>::operator()(const SPos<N1>& a) const
+    template <class PosT>
+    constexpr decltype(auto) SPos<N>::operator*(const PosT& a) const
     {
-	return SPos<N*N1>();
+	if constexpr(N == 0) {
+	    return SPos<0>{};
+	}
+	else if constexpr(is_static_pos_type<PosT>::value){
+	    return SPos<N*a.val()>{};
+	}
+	else {
+	    return UPos(N*a.val());
+	}
     }
 
     template <SizeT N>
-    constexpr decltype(auto) SPos<N>::operator+(const UPos& a) const
+    template <class PosT>
+    constexpr decltype(auto) SPos<N>::operator()(const PosT& a) const
     {
-	return UPos(N+a.val());
+	if constexpr(N == 0) {
+	    return SPos<0>{};
+	}
+	else if constexpr(is_static_pos_type<PosT>::value){
+	    return SPos<N*a.val()>{};
+	}
+	else {
+	    return UPos(N*a.val());
+	}
     }
     
-    template <SizeT N>
-    constexpr decltype(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 decltype(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>
     constexpr decltype(auto) SPos<N>::extend(const PosT& a) const
@@ -135,7 +131,12 @@ namespace CNORXZ
     template <class PosT>
     constexpr UPos UPos::operator+(const PosT& in) const
     {
-	return UPos(mExt + in.val());
+	if constexpr(is_epos_type<PosT>::value){
+	    return in+(*this);
+	}
+	else {
+	    return UPos(mExt + in.val());
+	}
     }
 
     template <class PosT>
@@ -144,26 +145,29 @@ namespace CNORXZ
 	return UPos(mExt - in.val());
     }
 
-    constexpr SPos<0> UPos::operator*(const SPos<0>& a) const
-    {
-	return SPos<0>();
-    }
-    
     template <class PosT>
-    constexpr UPos UPos::operator*(const PosT& in) const
+    constexpr decltype(auto) UPos::operator*(const PosT& in) const
     {
-	return UPos(mExt * in.val());
+	if constexpr(is_epos_type<PosT>::value){
+	    return in*(*this);
+	}
+	if constexpr(std::is_same<PosT,SPos<0>>::value){
+	    return SPos<0>{};
+	}
+	else {
+	    return UPos(mExt * in.val());
+	}
     }
 
-    constexpr SPos<0> UPos::operator()(const SPos<0>& a) const
-    {
-	return SPos<0>();
-    }
-	
     template <class PosT>
-    constexpr UPos UPos::operator()(const PosT& in) const
+    constexpr decltype(auto) UPos::operator()(const PosT& in) const
     {
-	return UPos(mExt * in.val());
+	if constexpr(std::is_same<PosT,SPos<0>>::value){
+	    return SPos<0>{};
+	}
+	else {
+	    return UPos(mExt * in.val());
+	}
     }
 	
     template <class PosT>
@@ -205,15 +209,15 @@ namespace CNORXZ
     {
 	return UPos(mExt + a.val());
     }
-
+    
     template <class PosT>
-    constexpr FPos FPos::operator*(const PosT& in) const
+    constexpr decltype(auto) FPos::operator*(const PosT& in) const
     {
 	return FPos(mExt * in.val(), mMap);
     }
-
+    
     template <class PosT1>
-    constexpr UPos FPos::operator()(const PosT1& a) const
+    constexpr decltype(auto) FPos::operator()(const PosT1& a) const
     {
 	return UPos(mExt * mMap[a.val()]);
     }
@@ -284,45 +288,42 @@ namespace CNORXZ
 	return N;
     }
 
-    template <SizeT N, SizeT... Ms>
-    template <SizeT N1>
-    constexpr auto SFPos<N,Ms...>::operator+(const SPos<N1>& a) const
+    template <SizeT N, SizeT... Ms> 
+    template <class PosT>
+    constexpr decltype(auto) SFPos<N,Ms...>::operator+(const PosT& a) const
     {
-	return SPos<N+N1>();
+	if constexpr(is_static_pos_type<PosT>::value){
+	    return SPos<N+a.val()>();
+	}
+	else {
+	    return UPos(N + a.val());
+	}
     }
     
-    template <SizeT N, SizeT... Ms>
-    template <SizeT N1>
-    constexpr auto SFPos<N,Ms...>::operator*(const SPos<N1>& a) const
+    template <SizeT N, SizeT... Ms> 
+    template <class PosT>
+    constexpr decltype(auto) SFPos<N,Ms...>::operator*(const PosT& a) const
     {
-	return SFPos<N*N1,Ms...>();
+	if constexpr(is_static_pos_type<PosT>::value){
+	    return SFPos<N*a.val(),Ms...>();
+	}
+	else {
+	    return FPos(N * a.val(), &sMs[0]);
+	}
     }
 
     template <SizeT N, SizeT... Ms>
-    template <SizeT N1>
-    constexpr auto SFPos<N,Ms...>::operator()(const SPos<N1>& a) const
+    template <class PosT>
+    constexpr decltype(auto) SFPos<N,Ms...>::operator()(const PosT& a) const
     {
-	constexpr Arr<SizeT,sizeof...(Ms)> ms({ Ms... });
-	return SPos<N*std::get<a.val()>(ms)>();
-    }
-
-    template <SizeT N, SizeT... Ms>
-    constexpr auto SFPos<N,Ms...>::operator+(const UPos& a) const
-    {
-	return UPos(N + a.val());
-    }
-    
-    template <SizeT N, SizeT... Ms>
-    constexpr auto SFPos<N,Ms...>::operator*(const UPos& a) const
-    {
-	return FPos(N * a.val(), &sMs[0]);
-    }
-
-    template <SizeT N, SizeT... Ms>
-    constexpr auto SFPos<N,Ms...>::operator()(const UPos& a) const
-    {
-	constexpr Arr<SizeT,sizeof...(Ms)> ms({ Ms... });
-	return UPos(N * ms[a.val()]);
+	if constexpr(is_static_pos_type<PosT>::value){
+	    constexpr Arr<SizeT,sizeof...(Ms)> ms({ Ms... });
+	    return SPos<N*std::get<a.val()>(ms)>();
+	}
+	else {
+	    constexpr Arr<SizeT,sizeof...(Ms)> ms({ Ms... });
+	    return UPos(N * ms[a.val()]);
+	}
     }
 
     template <SizeT N, SizeT... Ms>
diff --git a/src/include/xpr/pos_type.h b/src/include/xpr/pos_type.h
index b3b3368..8eba226 100644
--- a/src/include/xpr/pos_type.h
+++ b/src/include/xpr/pos_type.h
@@ -27,20 +27,19 @@ namespace CNORXZ
 	
 	constexpr SizeT size() const;
 	constexpr SizeT val() const;
-	
-	template <SizeT N1>
-	constexpr decltype(auto) operator+(const SPos<N1>& a) const;
+
 	template <SizeT N1>
 	constexpr decltype(auto) operator-(const SPos<N1>& a) const;
-	template <SizeT N1>
-	constexpr decltype(auto) operator*(const SPos<N1>& a) const;
-	template <SizeT N1>
-	constexpr decltype(auto) operator()(const SPos<N1>& a) const;
-	
-	constexpr decltype(auto) operator+(const UPos& a) const;
-	constexpr decltype(auto) operator*(const UPos& a) const;
-	constexpr decltype(auto) operator()(const UPos& a) const;
 
+	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;
+	
 	template <class PosT>
 	constexpr decltype(auto) extend(const PosT& a) const;
 	
@@ -69,15 +68,15 @@ namespace CNORXZ
 	template <class PosT>
 	constexpr UPos operator-(const PosT& a) const;
 
-	constexpr SPos<0> operator*(const SPos<0>& a) const;
+	//constexpr SPos<0> operator*(const SPos<0>& a) const;
 
         template <class PosT>
-	constexpr UPos operator*(const PosT& a) const;
+	constexpr decltype(auto) operator*(const PosT& a) const;
 
-	constexpr SPos<0> operator()(const SPos<0>& a) const;
+	//constexpr SPos<0> operator()(const SPos<0>& a) const;
 
 	template <class PosT>
-	constexpr UPos operator()(const PosT& a) const;
+	constexpr decltype(auto) operator()(const PosT& a) const;
 
         template <class PosT>
         constexpr decltype(auto) extend(const PosT& a) const;
@@ -107,10 +106,10 @@ namespace CNORXZ
 	constexpr UPos operator+(const PosT1& a) const;
 
 	template <class PosT1>
-	constexpr FPos operator*(const PosT1& a) const;
+	constexpr decltype(auto) operator*(const PosT1& a) const;
 
 	template <class PosT>
-	constexpr UPos operator()(const PosT& a) const;
+	constexpr decltype(auto) operator()(const PosT& a) const;
 
 	template <class PosT>
 	constexpr decltype(auto) extend(const PosT& a) const;
@@ -138,17 +137,15 @@ namespace CNORXZ
 	constexpr SizeT size() const;
 	constexpr SizeT val() 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;
+	template <class PosT>
+	constexpr decltype(auto) operator+(const PosT& a) const;
 
-	constexpr auto operator+(const UPos& a) const;
-	constexpr auto operator*(const UPos& a) const;
-	constexpr auto operator()(const UPos& a) const;
+	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) extend(const PosT& a) const;