From ca2e47b9867d2f40f64746755a46a290272dc160 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Thu, 29 Nov 2018 19:37:32 +0100
Subject: [PATCH] some utilities + corrections in 'call by lambda' operation

---
 src/include/helper_tools.h             | 10 ++++++-
 src/include/multi_array_base.cc.h      | 15 ++++++++++
 src/include/multi_array_base.h         | 39 ++++++++++++++++++++++++--
 src/include/multi_array_operation.cc.h |  4 +--
 src/include/multi_array_operation.h    |  2 +-
 src/include/ranges/container_range.h   |  9 ++++++
 src/include/ranges/rpack_num.h         | 13 +++++++++
 src/include/slice.h                    |  5 +++-
 8 files changed, 90 insertions(+), 7 deletions(-)

diff --git a/src/include/helper_tools.h b/src/include/helper_tools.h
index 39a5afb..c428adb 100644
--- a/src/include/helper_tools.h
+++ b/src/include/helper_tools.h
@@ -99,7 +99,15 @@ namespace MultiArrayTools
 			     typename Index::RangeType> fma(i->range());
 	return fma.exec(i);
     }
-        
+
+    template <typename R, typename... Ts>
+    struct Func
+    {
+        static inline std::shared_ptr<function<R,Ts...>> mk(const std::function<R(Ts...)>& ll)
+        {
+            return std::make_shared<function<R,Ts...>>(ll);
+        }
+    };
 }
 
 
diff --git a/src/include/multi_array_base.cc.h b/src/include/multi_array_base.cc.h
index 9d9dbd9..d4423a4 100644
--- a/src/include/multi_array_base.cc.h
+++ b/src/include/multi_array_base.cc.h
@@ -33,6 +33,13 @@ namespace MultiArrayTools
 	return (*this)[ii];
     }
 
+    template <typename T, class... SRanges>
+    const T& MultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const
+    {
+	IndexType ii(*mProtoI);
+	ii(is);
+	return (*this)[ii];
+    }
     
     template <typename T, class... SRanges>
     size_t MultiArrayBase<T,SRanges...>::size() const
@@ -164,6 +171,14 @@ namespace MultiArrayTools
 	return (*this)[ii];
     }
 
+    template <typename T, class... SRanges>
+    T& MutableMultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is)
+    {
+	IndexType ii(*MAB::mProtoI);
+	ii(is);
+	return (*this)[ii];
+    }
+
     
     template <typename T, class... SRanges>
     bool MutableMultiArrayBase<T,SRanges...>::isConst() const
diff --git a/src/include/multi_array_base.h b/src/include/multi_array_base.h
index e771d6c..879c528 100644
--- a/src/include/multi_array_base.h
+++ b/src/include/multi_array_base.h
@@ -16,6 +16,39 @@
 namespace MultiArrayTools
 {
 
+    template <class IndexType>
+    using IPTR = std::shared_ptr<IndexType>;
+    
+    template <class IndexType1, class IndexType2>
+    inline auto operator|(const IPTR<IndexType1>& i1, const IPTR<IndexType2>& i2)
+        -> decltype(std::make_tuple(i1->THIS(),i2->THIS()))
+    {
+        return std::make_tuple(i1->THIS(),i2->THIS());
+    }
+
+    template <class IndexType1, class... IndexTypes2>
+    inline auto operator|(const IPTR<IndexType1>& i1,
+                          const std::tuple<IPTR<IndexTypes2>...>& i2)
+        -> decltype(std::tuple_cat(std::make_tuple(i1),i2))
+    {
+        return std::tuple_cat(std::make_tuple(i1),i2);
+    }
+
+    template <class IndexType2, class... IndexTypes1>
+    inline auto operator|(const std::tuple<IPTR<IndexTypes1>...>& i1,
+                          const IPTR<IndexType2>& i2)
+        -> decltype(std::tuple_cat(i1,std::make_tuple(i2)))
+    {
+        return std::tuple_cat(i1,std::make_tuple(i2));
+    }
+
+    template <class IndexType>
+    inline auto operator~(const IPTR<IndexType>& i)
+        -> decltype(std::make_tuple(i))
+    {
+        return std::make_tuple(i);
+    }
+
     // Explicitely specify subranges in template argument !!!
     template <typename T, class... SRanges>
     class MultiArrayBase
@@ -41,7 +74,8 @@ namespace MultiArrayTools
 
 	template <typename X>
 	const T& operator[](const ContainerIndex<X,typename SRanges::IndexType...>& i);
-	
+        const T& operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const;
+        
 	virtual const T& operator[](const IndexType& i) const = 0;
 	virtual const T& at(const typename CRange::IndexType::MetaType& meta) const = 0;
 
@@ -101,7 +135,8 @@ namespace MultiArrayTools
 
 	template <typename X>
 	T& operator[](const ContainerIndex<X,typename SRanges::IndexType...>& i);
-	
+        T& operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is);
+        
 	virtual T& operator[](const IndexType& i) = 0;
 	virtual T& at(const typename CRange::IndexType::MetaType& meta) = 0;
 	
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 109ba11..e3e012c 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -78,11 +78,11 @@ namespace MultiArrayTools
 
     template <typename T, class OperationClass>
     template <typename R, class... Args>
-    auto OperationBase<T,OperationClass>::a(const function<R,T,typename Args::value_type...>& ll,
+    auto OperationBase<T,OperationClass>::a(const std::shared_ptr<function<R,T,typename Args::value_type...>>& ll,
                                             const Args&... args) const
         -> Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>
     {
-        return Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>(THIS(), args...);
+        return Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>(ll, THIS(), args...);
     }
 
     /*****************************************
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index ef4ecac..36dcbb9 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -62,7 +62,7 @@ namespace MultiArrayTools
 	    -> SliceContraction<T,OperationClass,Indices...>;
 
         template <typename R, class... Args> // Args = Operation Classes
-        auto a(const function<R,T,typename Args::value_type...>& ll, const Args&... args) const
+        auto a(const std::shared_ptr<function<R,T,typename Args::value_type...>>& ll, const Args&... args) const
             -> Operation<R,function<R,T,typename Args::value_type...>,OperationClass, Args...>;
         
     private:		
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index 090d873..6d8da63 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -82,6 +82,7 @@ namespace MultiArrayTools
 	
 	ContainerIndex& sync(); // recalculate 'IB::mPos' when externalControl == true
 	ContainerIndex& operator()(const std::shared_ptr<Indices>&... inds); // control via external indices
+        ContainerIndex& operator()(const std::tuple<std::shared_ptr<Indices>...>& inds);
 	ContainerIndex& operator()(); // -> sync; just to shorten the code
 
 	// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
@@ -305,6 +306,14 @@ namespace MultiArrayTools
 	return sync();
     }    
 
+    template <typename T, class... Indices>
+    ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()(const std::tuple<std::shared_ptr<Indices>...>& inds)
+    {
+	RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, inds);
+	mExternControl = true;
+	return sync();
+    }    
+
     template <typename T, class... Indices>
     ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::operator()()
     {
diff --git a/src/include/ranges/rpack_num.h b/src/include/ranges/rpack_num.h
index 470934d..fffd1ba 100644
--- a/src/include/ranges/rpack_num.h
+++ b/src/include/ranges/rpack_num.h
@@ -214,6 +214,13 @@ namespace MultiArrayHelper
 	    RPackNum<N-1>::swapIndices(ipack, ninds...);
 	}
 
+        template <class Pack, class... Indices>
+	static void swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds)
+	{
+	    std::get<N>(ipack) = std::get<N>(ninds);
+	    RPackNum<N-1>::swapIndices(ipack, ninds);
+	}
+
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
 	{
@@ -455,6 +462,12 @@ namespace MultiArrayHelper
 	    std::get<std::tuple_size<Pack>::value-1>(ipack) = nind;
 	}
 
+        template <class Pack, class... Indices>
+	static void swapIndices(Pack& ipack, const std::tuple<std::shared_ptr<Indices>...>& ninds)
+	{
+	    std::get<0>(ipack) = std::get<0>(ninds);
+	}
+
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
 	{
diff --git a/src/include/slice.h b/src/include/slice.h
index ff6eb70..e727a46 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -17,6 +17,7 @@ namespace MultiArrayTools
 	typedef ContainerIndex<T,typename SRanges::IndexType...> IType;
 
 	using MultiArrayBase<T,SRanges...>::operator();
+        using MultiArrayBase<T,SRanges...>::operator[];
 	
 	DEFAULT_MEMBERS(ConstSlice);
 
@@ -60,7 +61,9 @@ namespace MultiArrayTools
 
 	using MultiArrayBase<T,SRanges...>::operator();
 	using MutableMultiArrayBase<T,SRanges...>::operator();
-	
+        using MultiArrayBase<T,SRanges...>::operator[];
+	using MutableMultiArrayBase<T,SRanges...>::operator[];
+
 	DEFAULT_MEMBERS(Slice);
 
 	Slice(const std::shared_ptr<SRanges>&... ranges, T* data = nullptr);