slice + blockSize fix -> simple slice calls work so far

src/include/multi_array_operation.h

@@ -170,6 +170,8 @@ namespace MultiArrayTools
 
 	template <class Expr>
 	Expr loop(Expr exp) const;
+
+	T* data() const;
 	
     private:
 
@@ -469,6 +471,12 @@ namespace MultiArrayTools
     {
 	return exp;
     }
+
+    template <typename T, class... Ranges>
+    T* OperationRoot<T,Ranges...>::data() const
+    {
+	return mDataPtr + mIndex.pos();
+    }
     
     /*******************
      *   Operation     *

src/include/pack_num.h

@@ -56,6 +56,19 @@ namespace MultiArrayHelper
 	{
 	    return std::get<N>(ot).loop( PackNum<N-1>::mkLoop(ot,exp) );
 	}
+
+	template <typename T, class Op, class... SRanges>
+	static void mkSliceBlocks(std::array<size_t, sizeof...(SRanges)+1>& blocks,
+				  const ContainerIndex<T,typename SRanges::IndexType...>& index,
+				  const Op& op, size_t total = 1)
+	{
+	    const size_t tmp = 
+		op.rootSteps(reinterpret_cast<std::intptr_t>
+			     ( index.template getPtr<N>().get() ) )
+		.val();
+	    std::get<N+1>(blocks) = tmp;
+	    PackNum<N-1>::mkSliceBlocks(blocks, index, op, total * tmp);
+	}
     };
     
     template<>
@@ -98,7 +111,19 @@ namespace MultiArrayHelper
 	    return std::get<0>(ot).loop( exp );
 	}
 
-	
+	template <typename T, class Op, class... SRanges>
+	static void mkSliceBlocks(std::array<size_t, sizeof...(SRanges)+1>& blocks,
+				  const ContainerIndex<T,typename SRanges::IndexType...>& index,
+				  const Op& op, size_t total = 1)
+	{
+	    const size_t tmp = 
+		op.rootSteps(reinterpret_cast<std::intptr_t>
+			     ( index.template getPtr<0>().get() ) )
+		.val();
+	    std::get<1>(blocks) = tmp;
+	    std::get<0>(blocks) = total * tmp; // this is not correct, but not used so far ... !!!
+	}
+
     };
 
 

src/include/ranges/container_range.h

@@ -346,7 +346,7 @@ namespace MultiArrayTools
     ContainerIndex<T,Indices...>& ContainerIndex<T,Indices...>::at(const MetaType& metaPos)
     {
 	RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
-	IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
+	IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack, mBlockSizes);
 	return *this;
     }
 

src/include/ranges/rpack_num.h

@@ -46,7 +46,7 @@ namespace MultiArrayHelper
 	static void initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
 				   std::tuple<std::shared_ptr<Indices>...>& ip)
 	{
-	    std::get<N>(bs) = RPackNum<sizeof...(Indices)-N-1>::blockSize(ip);
+	    std::get<N>(bs) = RPackNum<sizeof...(Indices)-N>::blockSize(ip);
 	    RPackNum<N-1>::initBlockSizes(bs, ip);
 	}
 	
@@ -183,7 +183,7 @@ namespace MultiArrayHelper
 	static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize)
 	{
-	    return RPackNum<N-1>::makePos(iPtrTup, blockSize) + std::get<N>(iPtrTup)->pos() * std::get<N>(blockSize);
+	    return RPackNum<N-1>::makePos(iPtrTup, blockSize) + std::get<N>(iPtrTup)->pos() * std::get<N+1>(blockSize);
 	}
 
 	template <class Pack, class IndexType, class... Indices>
@@ -197,7 +197,7 @@ namespace MultiArrayHelper
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
 	{
-	    return std::get<sizeof...(Indices)-N-1>(pack)->max() * RPackNum<N-1>::blockSize(pack);
+	    return std::get<sizeof...(Indices)-N>(pack)->max() * RPackNum<N-1>::blockSize(pack);
 	}
 
 
@@ -265,7 +265,7 @@ namespace MultiArrayHelper
 	static void initBlockSizes(std::array<size_t,sizeof...(Indices)+1>& bs,
 				   std::tuple<std::shared_ptr<Indices>...>& ip)
 	{
-	    std::get<0>(bs) = RPackNum<sizeof...(Indices)-1>::blockSize(ip);
+	    std::get<0>(bs) = RPackNum<sizeof...(Indices)>::blockSize(ip);
 	}
 
 	template <class... Indices>
@@ -370,7 +370,7 @@ namespace MultiArrayHelper
 	static inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
 				     const std::array<size_t,sizeof...(Indices)+1>& blockSize)
 	{
-	    return std::get<0>(iPtrTup)->pos() * std::get<0>(blockSize);
+	    return std::get<0>(iPtrTup)->pos() * std::get<1>(blockSize);
 	}
 
 	template <class Pack, class IndexType>
@@ -382,7 +382,7 @@ namespace MultiArrayHelper
 	template <class... Indices>
 	static size_t blockSize(const std::tuple<std::shared_ptr<Indices>...>& pack)
 	{
-	    return std::get<sizeof...(Indices)-1>(pack)->max();
+	    return 1;
 	}
 
 	template <class... Ranges>

src/include/slice.h

@@ -18,7 +18,7 @@ namespace MultiArrayTools
 	
 	DEFAULT_MEMBERS(Slice);
 
-	Slice(T* data, const std::shared_ptr<SRanges>&... ranges);
+	Slice(const std::shared_ptr<SRanges>&... ranges, T* data = nullptr);
 	    
 	virtual const T& operator[](const IType& i) const override;
 	virtual T& operator[](const IType& i) override;
@@ -33,11 +33,14 @@ namespace MultiArrayTools
 	virtual auto begin() const -> IType override;
 	virtual auto end() const -> IType override;
 
-	template <class... MARanges>
+	auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
-	auto define(const std::shared_ptr<typename SRanges::IType>&... inds)
+	    -> SliceDef<T,SRanges...>;
-	    -> SliceDef<T,MARanges...>;
 	
     private:
+	friend SliceDef<T,SRanges...>;
+
+	void format(const std::array<size_t,sizeof...(SRanges)+1>& blocks);
+	
 	T* mData;
     };
 
@@ -45,15 +48,20 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     class SliceDef
     {
-    private:
+    public:
-	SliceDef() = default;
+	typedef ContainerIndex<T,typename SRanges::IndexType...> IType;
 	
+    private:
+	IType mIndex;
+	Slice<T,SRanges...>& mSl;
+	
+	SliceDef() = default;
     public:
 	SliceDef(Slice<T,SRanges...>& sl,
 		 const std::shared_ptr<typename SRanges::IndexType>&... inds);
 
 	template <class... ORanges>
-	SliceDef& operator=(OperationRoot<T,ORanges...>& op);
+	SliceDef& operator=(const OperationRoot<T,ORanges...>& op);
     };
     
 } // end namespace MultiArrayTools
@@ -70,14 +78,20 @@ namespace MultiArrayTools
      *************/
 
     template <typename T, class... SRanges>
-    Slice<T,SRanges...>::Slice(T* data, const std::shared_ptr<SRanges>&... ranges) :
+    void Slice<T,SRanges...>::format(const std::array<size_t,sizeof...(SRanges)+1>& blocks)
+    {
+	MAB::mProtoI->format(blocks);
+    }
+    
+    template <typename T, class... SRanges>
+    Slice<T,SRanges...>::Slice(const std::shared_ptr<SRanges>&... ranges, T* data) :
 	MutableMultiArrayBase<T,SRanges...>(ranges...),
 	mData(data) {}
     
     template <typename T, class... SRanges>
     const T& Slice<T,SRanges...>::operator[](const IType& i) const
     {
-	assert(i.sliceMode()); // -> compare objects !!!!!
+	//assert(i.sliceMode()); // -> compare objects !!!!!
 	assert(i.container() == reinterpret_cast<std::intptr_t>(this));
 	return mData[ i.pos() ];
     }
@@ -85,7 +99,7 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     T& Slice<T,SRanges...>::operator[](const IType& i)
     {
-	assert(i.sliceMode());
+	//assert(i.sliceMode());
 	assert(i.container() == reinterpret_cast<std::intptr_t>(this));
 	return mData[ i.pos() ];
     }
@@ -93,12 +107,16 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     const T& Slice<T,SRanges...>::at(const typename IType::MetaType& meta) const
     {
+	//auto x = begin().at(meta);
+	//VCHECK(x.pos());
 	return mData[ begin().at(meta).pos() ];
     }
     
     template <typename T, class... SRanges>
     T& Slice<T,SRanges...>::at(const typename IType::MetaType& meta)
     {
+	//auto x = begin().at(meta);
+	//VCHECK(x.pos());
 	return mData[ begin().at(meta).pos() ];
     }
     
@@ -123,7 +141,7 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     auto Slice<T,SRanges...>::begin() const -> Slice<T,SRanges...>::IType 
     {
-	IType i = MAB::mProtoI;
+	IType i(*MAB::mProtoI);
 	i = 0;
 	//i = mStartPos;
 	return i.setData(data());
@@ -132,19 +150,42 @@ namespace MultiArrayTools
     template <typename T, class... SRanges>
     auto Slice<T,SRanges...>::end() const -> Slice<T,SRanges...>::IType 
     {
-	IType i = MAB::mProtoI;
+	IType i(*MAB::mProtoI);
 	i = i.max(); // CHECK !!!
 	//i = std::get<sizeof...(SRanges)>(mBlockSizes);
 	return i.setData(data());
     }
-    /*
+
-    SliceDef<T,SRanges...>::
+    template <typename T, class... SRanges>
-    SliceDef(Slice<T,SRanges...>& sl,
+    auto Slice<T,SRanges...>::define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
-	     const std::shared_ptr<typename SRanges::IndexType>&... inds);
+	-> SliceDef<T,SRanges...>
+    {
+	return SliceDef<T,SRanges...>(*this, inds...);
+    }
     
+    template <typename T, class... SRanges>
+    SliceDef<T,SRanges...>::SliceDef(Slice<T,SRanges...>& sl,
+				     const std::shared_ptr<typename SRanges::IndexType>&... inds) :
+	mIndex(sl.begin()),
+	mSl(sl)
+    {
+	mIndex(inds...);
+    }
+
+    template <typename T, class... SRanges>
     template <class... ORanges>
-    SliceDef<T,SRanges...>& SliceDef<T,SRanges...>::operator=(OperationRoot<T,ORanges...>& op);
+    SliceDef<T,SRanges...>& SliceDef<T,SRanges...>::operator=(const OperationRoot<T,ORanges...>& op)
-    */
+    {
+	std::array<size_t,sizeof...(SRanges)+1> blocks;
+	PackNum<sizeof...(SRanges)-1>::
+	    template mkSliceBlocks<T,OperationRoot<T,ORanges...>,SRanges...>(blocks, mIndex, op);
+	mSl.format(blocks);
+	//VCHECK(blocks[0]);
+	//VCHECK(blocks[1]);
+	mSl.mData = op.data();
+	return *this;
+    }
+    
 
 } // end namespace MultiArrayTools
 

src/tests/ma_unit_test.cc

@@ -95,7 +95,7 @@ namespace {
 				   8.870, 4.790, 8.215, 5.063, 1.530, 3.084, 1.609, 4.847,
 				   8.175, 0.112, 6.712, 6.408, 1.959, 0.331, 4.209, 2.951 };
     };
-    
+
     TEST_F(MATest_1Dim, SimpleCall)
     {
 	MultiArray<double,MATest_1Dim::SRange> ma(srptr, vv);
@@ -185,7 +185,34 @@ namespace {
 	EXPECT_EQ( ma2[ i.at('M') ], 1.530 );
 	EXPECT_EQ( ma2.at('W') , 4.209 );
     }
-    
+
+    TEST_F(MATest_MDim, SliceTest1)
+    {
+	MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
+	Slice<double,MATest_MDim::SRange> sl(sr3ptr);
+
+	auto i = MAT::getIndex(sr3ptr);
+	auto mi = MAT::getIndex(mrptr);
+	mi->at( mkt('y', 'f') );
+	sl.define(i) = ma(mi, i);
+
+	EXPECT_EQ( sl.at('1'), 6.712 );
+	EXPECT_EQ( sl.at('2'), 6.408 );
+	EXPECT_EQ( sl.at('3'), 1.959 );
+	
+	Slice<double,SRange> sl2(sr2ptr);
+	auto j = MAT::getIndex(sr3ptr);
+	auto mj = MAT::getIndex(mrptr);
+	mj->at( mkt('y','a') );
+	j->at('2');
+	auto jj = mj->template getPtr<1>();
+	sl2.define(jj) = ma(mj, j);
+
+	EXPECT_EQ( sl2.at('a'), 3.084 );
+	EXPECT_EQ( sl2.at('l'), 8.175 );
+	EXPECT_EQ( sl2.at('f'), 6.408 );
+	EXPECT_EQ( sl2.at('g'), 4.209 );
+    }
     
 } // end namespace