From 64bd8f2702abbd1758eeab499139e2eb0ef820ab Mon Sep 17 00:00:00 2001
From: Wolfgang Draxinger <dw@optores.de>
Date: Thu, 18 Jul 2019 14:14:00 +0200
Subject: added mixed containers same type support

---
 include/dwu/operators | 70 +++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 63 insertions(+), 7 deletions(-)

diff --git a/include/dwu/operators b/include/dwu/operators
index b4b5210..bb52a57 100644
--- a/include/dwu/operators
+++ b/include/dwu/operators
@@ -23,8 +23,6 @@
 #ifndef DWU__OPERATORS__
 #define DWU__OPERATORS__ 1
 
-#include <algorithm>
-
 namespace dwu {
 	namespace operators {
 		// same container, same type
@@ -49,7 +47,8 @@ namespace dwu {
 		} \
 		template<template<typename,typename> class C, typename T, typename A> \
 		C<T,A> operator O (C<T,A> const &l, C<T,A> const &r) { \
-			C<T,A> v( std::min(l.size(), r.size()) ); \
+			auto const lsz = l.size(); auto const rsz = r.size(); \
+			C<T,A> v( (lsz < rsz) ? lsz : rsz ); \
 			auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
 			while( vi != v.end() ){ \
 				*vi++ = *li++ O *ri++; \
@@ -83,7 +82,9 @@ DWU_OPERATORS(|)
 	namespace operators_xt {
 		// same container, mixed type
 #define DWU_OPERATORS_XT(O) \
-		template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
+		template< \
+			template<typename,typename> class C, \
+			typename Tl, typename A, typename Tr > \
 		C<Tl,A> operator O (C<Tl,A> const &l, Tr const &r) { \
 			C<Tl,A> v(l.size()); \
 			auto vi = v.begin(); auto li = l.begin(); \
@@ -92,7 +93,9 @@ DWU_OPERATORS(|)
 			} \
 			return v; \
 		} \
-		template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
+		template< \
+			template<typename,typename> class C, \
+			typename Tl, typename A, typename Tr > \
 		C<Tr,A> operator O (Tl const &l, C<Tr,A> const &r) { \
 			C<Tr,A> v(r.size()); \
 			auto vi = v.begin(); auto ri = r.begin(); \
@@ -101,7 +104,21 @@ DWU_OPERATORS(|)
 			} \
 			return v; \
 		} \
-		template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
+		template< \
+			template<typename,typename> class C, \
+			typename Tl, typename A, typename Tr > \
+		C<Tl,A> operator O (C<Tl,A> const &l, C<Tr,A> const &r) { \
+			auto const lsz = l.size(); auto const rsz = r.size(); \
+			C<Tl,A> v( (lsz < rsz) ? lsz : rsz ); \
+			auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = *li++ O *ri++; \
+			} \
+			return v; \
+		} \
+		template< \
+			template<typename,typename> class C, \
+			typename Tl, typename A, typename Tr > \
 		C<Tl,A>& operator O##= (C<Tl,A> &l, Tr const &r){ \
 			for(auto &x:l){ x O##= r; } \
 			return l; \
@@ -117,6 +134,44 @@ DWU_OPERATORS_XT(|)
 #undef DWU_OPERATORS_XT
 	}
 
+	namespace operators_xc {
+		// mixed container, same type
+#define DWU_OPERATORS_XC(O) \
+		template< \
+			template<typename,typename> class Cl, \
+			template<typename,typename> class Cr, \
+			typename T, typename A > \
+		Cl<T,A> operator O (Cl<T,A> const &l, Cr<T,A> const &r) { \
+			auto const lsz = l.size(); auto const rsz = r.size(); \
+			Cl<T,A> v( (lsz < rsz) ? lsz : rsz ); \
+			auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = *li++ O *ri++; \
+			} \
+			return v; \
+		} \
+		template< \
+			template<typename,typename> class Cl, \
+			template<typename,typename> class Cr, \
+			typename T, typename A > \
+		Cl<T,A>& operator O##= (Cl<T,A> &l, Cr<T,A> const &r){ \
+			auto li = l.begin(); auto ri = r.begin(); \
+			while( li != l.end() && ri != r.end() ){ \
+				*li++ O##= *ri++; \
+			} \
+			return l; \
+		}
+DWU_OPERATORS_XC(+)
+DWU_OPERATORS_XC(-)
+DWU_OPERATORS_XC(*)
+DWU_OPERATORS_XC(/)
+DWU_OPERATORS_XC(%)
+DWU_OPERATORS_XC(^)
+DWU_OPERATORS_XC(&)
+DWU_OPERATORS_XC(|)
+#undef DWU_OPERATORS_XC
+	}
+
 	namespace operators_xcxt {
 		// mixed container, mixed type
 #define DWU_OPERATORS_XCXT(O) \
@@ -126,7 +181,8 @@ DWU_OPERATORS_XT(|)
 			typename Tl, typename Al, \
 			typename Tr, typename Ar > \
 		Cl<Tl,Al> operator O (Cl<Tl,Al> const &l, Cr<Tr,Ar> const &r) { \
-			Cl<Tl,Al> v( std::min(l.size(), r.size()) ); \
+			auto const lsz = l.size(); auto const rsz = r.size(); \
+			Cl<Tl,Al> v( (lsz < rsz) ? lsz : rsz ); \
 			auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
 			while( vi != v.end() ){ \
 				*vi++ = *li++ O *ri++; \
-- 
cgit v1.2.3