From ae534e24939574993c80288d9489f06daff77c37 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Mon, 26 Nov 2018 13:13:23 +0100
Subject: [PATCH] use meta operation in fma (should be faster)

---
 src/include/functional_multi_array.cc.h | 12 ++++++++--
 src/include/functional_multi_array.h    |  5 ++--
 src/include/multi_array_operation.cc.h  | 32 +++++++++++++------------
 src/include/multi_array_operation.h     | 16 ++++++-------
 4 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/src/include/functional_multi_array.cc.h b/src/include/functional_multi_array.cc.h
index 97086a3..fd116c0 100644
--- a/src/include/functional_multi_array.cc.h
+++ b/src/include/functional_multi_array.cc.h
@@ -112,7 +112,7 @@ namespace MultiArrayTools
  	return mkOperation( mFunc, ConstOperationRoot<typename SRanges::IndexType::MetaType,SRanges>( mkMAObject( inds ), inds ) ... );
     }
     */
-
+    /*
     template <typename T, class Function, class... SRanges>
     auto FunctionalMultiArray<T,Function,SRanges...>::
     exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
@@ -120,5 +120,13 @@ namespace MultiArrayTools
     {
  	return mkOperation( mFunc, mkOpObject(inds) ... );
     }
-
+    */
+    template <typename T, class Function, class... SRanges>
+    auto FunctionalMultiArray<T,Function,SRanges...>::
+    exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
+	-> Operation<T,Function,MetaOperationRoot<SRanges>...>
+    {
+        return mkOperation( mFunc, MetaOperationRoot<SRanges>( inds ) ... );
+    }
+    
 } // namespace MultiArrayTools
diff --git a/src/include/functional_multi_array.h b/src/include/functional_multi_array.h
index cf507c4..9bc3d6d 100644
--- a/src/include/functional_multi_array.h
+++ b/src/include/functional_multi_array.h
@@ -133,8 +133,9 @@ namespace MultiArrayTools
 
 	auto exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
 	//	    -> decltype( mkOperation( mFunc, ConstOperationRoot<typename SRanges::IndexType::MetaType,SRanges>( mkMAObject( inds ), inds) ... ) );
-	    -> decltype( mkOperation( mFunc, mkOpObject(inds) ... ) );
-	    
+        //-> decltype( mkOperation( mFunc, mkOpObject(inds) ... ) );
+            -> Operation<T,Function,MetaOperationRoot<SRanges>...>;
+            
 	virtual ConstOperationRoot<T,SRanges...>
 	operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const override;
 	
diff --git a/src/include/multi_array_operation.cc.h b/src/include/multi_array_operation.cc.h
index 087ac5e..3c24e3c 100644
--- a/src/include/multi_array_operation.cc.h
+++ b/src/include/multi_array_operation.cc.h
@@ -261,41 +261,43 @@ namespace MultiArrayTools
      *   MetaOperationRoot     *
      ****************************/
 
-    template <class... Ranges>
-    MetaOperationRoot<Ranges...>::
-    MetaOperationRoot(const IndexType& ind) :
+    template <class Range>
+    MetaOperationRoot<Range>::
+    MetaOperationRoot(const std::shared_ptr<IndexType>& ind) :
 	mIndex( ind ) { }
 
-    template <class... Ranges>
+    
+    template <class Range>
     template <class ET>
-    inline typename MetaOperationRoot<Ranges...>::value_type
-    MetaOperationRoot<Ranges...>::get(ET pos) const
+    inline typename MetaOperationRoot<Range>::value_type
+    MetaOperationRoot<Range>::get(ET pos) const
     {
 	//VCHECK(pos.val());
 	//VCHECK(mDataPtr);
 	//VCHECK(mDataPtr[pos.val()])
-	return mIndex.meta(pos.val());
+	return mIndex->range()->get( pos.val() );
     }
 
-    template <class... Ranges>
+    template <class Range>
     template <class ET>
-    inline const MetaOperationRoot<Ranges...>& MetaOperationRoot<Ranges...>::set(ET pos) const
+    inline const MetaOperationRoot<Range>& MetaOperationRoot<Range>::set(ET pos) const
     {
-	mIndex = pos.val();
+        assert(0);
+	//(*mIndex) = pos.val();
 	return *this;
     }
 
-    template <class... Ranges>
-    MExt<void> MetaOperationRoot<Ranges...>::rootSteps(std::intptr_t iPtrNum) const
+    template <class Range>
+    MExt<void> MetaOperationRoot<Range>::rootSteps(std::intptr_t iPtrNum) const
     {
-	return MExt<void>(getStepSize( mIndex, iPtrNum ));
+	return MExt<void>(getStepSize( *mIndex, iPtrNum ));
 	//return MExt<void>(getStepSize( getRootIndices( mIndex->info() ), iPtrNum ));
     }
 
 
-    template <class... Ranges>
+    template <class Range>
     template <class Expr>
-    Expr MetaOperationRoot<Ranges...>::loop(Expr exp) const
+    Expr MetaOperationRoot<Range>::loop(Expr exp) const
     {
 	return exp;
     }
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index ba2f893..8d826a2 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -217,21 +217,19 @@ namespace MultiArrayTools
 	return StaticCast<T,Op>(op);
     }
     
-    template <class... Ranges>
-    class MetaOperationRoot : public OperationTemplate<std::tuple<typename Ranges::IndexType...>,
-						       MetaOperationRoot<Ranges...> >
+    template <class Range>
+    class MetaOperationRoot : public OperationTemplate<typename Range::MetaType,
+						       MetaOperationRoot<Range> >
     {
     public:
 
-	typedef ContainerIndex<std::tuple<typename Ranges::IndexType::MetaType...>,
-			       typename Ranges::IndexType...> IndexType;
+	typedef typename Range::IndexType IndexType;
 	typedef typename IndexType::MetaType value_type;
-	typedef OperationBase<value_type,MetaOperationRoot<Ranges...> > OT;
-	typedef ContainerRange<value_type,Ranges...> CRange;
+	typedef OperationBase<value_type,MetaOperationRoot<Range> > OT;
 	
 	static constexpr size_t SIZE = 1;
 	
-	MetaOperationRoot(const IndexType& ind);
+	MetaOperationRoot(const std::shared_ptr<IndexType>& ind);
 
 	template <class ET>
 	inline value_type get(ET pos) const;
@@ -248,7 +246,7 @@ namespace MultiArrayTools
 
 	//MultiArrayBase<T,Ranges...> const& mArrayRef;
 	//const T* mDataPtr;
-	IndexType mIndex;
+        std::shared_ptr<IndexType> mIndex;
     };
 
     template <typename T, class... Ranges>