From 9e5c51428a75f42bc7dc89d065df146481cb6b49 Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Mon, 20 Aug 2018 17:50:04 +0200
Subject: [PATCH] various fixes and adds -> map range test works

---
 src/include/arith.h                  |   4 +
 src/include/functional_multi_array.h |  13 +++
 src/include/map_range.h              | 138 +++++++++++++++++----------
 src/include/multi_array_base.h       |  34 +++++--
 src/include/multi_array_operation.h  |   6 +-
 src/include/ranges/container_range.h |   5 +-
 src/include/ranges/single_range.h    |  11 ++-
 src/tests/op_unit_test.cc            |  68 +++++++++++++
 8 files changed, 211 insertions(+), 68 deletions(-)

diff --git a/src/include/arith.h b/src/include/arith.h
index 76cfb71..af47bdc 100644
--- a/src/include/arith.h
+++ b/src/include/arith.h
@@ -63,6 +63,7 @@ namespace MultiArrayTools
     struct plus : public StaticFunctionBase<T, plus<T>, T, T>
     {
 	static constexpr bool FISSTATIC = true;
+	using StaticFunctionBase<T, plus<T>, T, T>::apply;
 	
 	static inline T apply(T a1, T a2)
 	{
@@ -74,6 +75,7 @@ namespace MultiArrayTools
     struct minus : public StaticFunctionBase<T, minus<T>, T, T>
     {
 	static constexpr bool FISSTATIC = true;
+	using StaticFunctionBase<T, minus<T>, T, T>::apply;
 	
 	static inline T apply(T a1, T a2)
 	{
@@ -85,6 +87,7 @@ namespace MultiArrayTools
     struct multiplies : public StaticFunctionBase<T, multiplies<T>, T, T>
     {
 	static constexpr bool FISSTATIC = true;
+	using StaticFunctionBase<T, multiplies<T>, T, T>::apply;
 	
 	static inline T apply(T a1, T a2)
 	{
@@ -96,6 +99,7 @@ namespace MultiArrayTools
     struct divides : public StaticFunctionBase<T, divides<T>, T, T>
     {
 	static constexpr bool FISSTATIC = true;
+	using StaticFunctionBase<T, divides<T>, T, T>::apply;
 	
 	static inline T apply(T a1, T a2)
 	{
diff --git a/src/include/functional_multi_array.h b/src/include/functional_multi_array.h
index 3429b9c..a919417 100644
--- a/src/include/functional_multi_array.h
+++ b/src/include/functional_multi_array.h
@@ -104,6 +104,7 @@ namespace MultiArrayTools
 	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	//typedef typename CRange::IndexType IndexType;
 	typedef MultiArray<T,SRanges...> MAType;
+	typedef T value_type;
 	
     private:
 	mutable T mVal;
@@ -116,6 +117,8 @@ namespace MultiArrayTools
 	DEFAULT_MEMBERS(FunctionalMultiArray);
 	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges, const Function& func);
 	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges);
+	FunctionalMultiArray(const typename CRange::Space& space);
+	FunctionalMultiArray(const typename CRange::Space& space, const Function& func);
 	
 	virtual const T& operator[](const IndexType& i) const override;
 	virtual const T& at(const typename CRange::IndexType::MetaType& meta) const override;
@@ -186,6 +189,16 @@ namespace MultiArrayTools
     FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges) :
 	MultiArrayBase<T,SRanges...>(ranges...) {}
 
+    template <typename T, class Function, class... SRanges>
+    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space) :
+	MultiArrayBase<T,SRanges...>(space) {}
+
+    template <typename T, class Function, class... SRanges>
+    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space,
+								      const Function& func) :
+	MultiArrayBase<T,SRanges...>(space), mFunc(func) {}
+
+    
     template <typename T, class Function, class... SRanges>
     const T& FunctionalMultiArray<T,Function,SRanges...>::operator[](const IndexType& i) const
     {
diff --git a/src/include/map_range.h b/src/include/map_range.h
index e434641..a3aea41 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -29,17 +29,17 @@ namespace MultiArrayTools
     template <class MA, class... Indices>
     auto mkMapOp(const MA& ma,
 		 const std::tuple<std::shared_ptr<Indices>...>& itp)
-	-> ConstOperationRoot<typename MA::value_type,typename Indices::RangeType...>
+	-> decltype(PackNum<sizeof...(Indices)-1>::mkMapOp(ma, itp))
     {
 	return PackNum<sizeof...(Indices)-1>::mkMapOp(ma, itp);
     }
     
-    template <class MapF, class Expr>
+    template <class MapF, class IndexPack, class Expr>
     class OpExpr
     {
     public:
 	typedef SingleIndex<typename MapF::value_type,SpaceType::ANY> OIType;
-	typedef typename MapF::IndexPack IndexPack;
+	//typedef typename MapF::IndexPack IndexPack;
 	static constexpr size_t LAYER = Expr::LAYER + 1;
 	static constexpr size_t SIZE = Expr::SIZE;
 	
@@ -82,13 +82,13 @@ namespace MultiArrayTools
 			       std::tuple<typename Indices::MetaType...> > IB;
 	typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
 	typedef std::tuple<typename Indices::MetaType...> MetaType;
-	typedef MapRange<typename Indices::RangeType...> RangeType;
+	typedef MapRange<MapF,typename Indices::RangeType...> RangeType;
 	typedef MapIndex IType;
 	typedef SingleIndex<typename MapF::value_type,SpaceType::ANY> OIType;
 	
 	static constexpr IndexType sType() { return IndexType::MULTI; }
 	static constexpr size_t sDim() { return sizeof...(Indices); }
-	static constexpr size_t totalDim() { return mkTotalDim<MapF,Indices...>(); }
+	static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }
 
 	static constexpr SpaceType STYPE = SpaceType::ANY;
 	
@@ -148,23 +148,23 @@ namespace MultiArrayTools
 	MetaType meta() const;
 	MapIndex& at(const MetaType& metaPos);
 	
-	size_t dim();
-	bool first();
-	bool last();
-	std::shared_ptr<RangeType> range();
+	size_t dim() const;
+	bool first() const;
+	bool last() const;
+	std::shared_ptr<RangeType> range() const;
 
 	template <size_t N>
 	auto getPtr() -> decltype( std::get<N>( mIPack ) )&;
 
-	size_t getStepSize(size_t n);
+	size_t getStepSize(size_t n) const;
 
 	std::string id() const;
-	void print(size_t offset);
+	void print(size_t offset) const;
 
 	template <class Exprs>
 	auto ifor(Exprs exs) const
-	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkFor
-			(mIPack, OpExpr<MapF,Exprs>( range()->map(), mIPack, mOutIndex, exs ) ) );
+	    -> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
+			(mIPack, OpExpr<MapF,IndexPack,Exprs>( range()->map(), mIPack, mOutIndex, exs ) ) );
 	    
 	/*
 	template <class Exprs>
@@ -208,12 +208,12 @@ namespace MultiArrayTools
      ******************/
     
     template <class MapF, class... Ranges>
-    class MapRange : public RangeInterface<MapIndex<typename Ranges::IndexType...> >
+    class MapRange : public RangeInterface<MapIndex<MapF,typename Ranges::IndexType...> >
     {
     public:
 	typedef RangeBase RB;
 	typedef std::tuple<std::shared_ptr<Ranges>...> Space;
-	typedef MapIndex<typename Ranges::IndexType...> IndexType;
+	typedef MapIndex<MapF,typename Ranges::IndexType...> IndexType;
 	typedef MapRange RangeType;
 	typedef SingleRange<typename MapF::value_type,SpaceType::ANY> ORType;
 	typedef SingleRangeFactory<typename MapF::value_type,SpaceType::ANY> ORFType;
@@ -230,10 +230,14 @@ namespace MultiArrayTools
 	Space mSpace;
 	const MapF& mMapf;
 	std::shared_ptr<ORType> mOutRange;
+	MultiArray<size_t,ORType> mMapMult;
 
+    private:
+	void mkOutRange();
+	
     public:
 	
-	static const size_t sdim = sizeof...(Ranges);
+	static constexpr size_t sdim = sizeof...(Ranges);
 
 	template <size_t N>
 	auto get() const -> decltype( *std::get<N>( mSpace ) )&;
@@ -257,6 +261,8 @@ namespace MultiArrayTools
 	virtual IndexType begin() const final;
 	virtual IndexType end() const final;
 
+	const MultiArray<size_t,ORType>& mapMultiplicity() const;
+	
 	template <class... ERanges>
 	auto cat(const std::shared_ptr<MapRange<ERanges...> >& erange)
 	    -> std::shared_ptr<MapRange<Ranges...,ERanges...> >;
@@ -287,42 +293,44 @@ namespace MultiArrayTools
      *   OpExpr   *
      **************/
 
-    template <class MapF, class Expr>
-    OpExpr<MapF,Expr>::OpExpr(const MapF& mapf, const IndexPack& ipack,
-			      const std::shared_ptr<OIType> oind, Expr ex) :
+    template <class MapF, class IndexPack, class Expr>
+    OpExpr<MapF,IndexPack,Expr>::OpExpr(const MapF& mapf, const IndexPack& ipack,
+					 const std::shared_ptr<OIType> oind, Expr ex) :
 	mIndPtr(oind.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mExpr(ex),
-	mExt(ex.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr.get() ))),
-	mOp(mapf, ipack)
+	mOp(mkMapOp(mapf, ipack)),
+	//mExt(ex.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
+	mExt( mOp.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr) ).extend
+	      ( mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr) ) ) )
     {
 	assert(mIndPtr != nullptr);
 	//VCHECK(mIndPtr->id());
 	//VCHECK(mIndPtr->max());
     }
     
-    template <class MapF, class Expr>
-    inline void OpExpr<MapF,Expr>::operator()(size_t mlast,
-					      ExtType last) const
+    template <class MapF, class IndexPack, class Expr>
+    inline void OpExpr<MapF,IndexPack,Expr>::operator()(size_t mlast,
+							 ExtType last) const
     {
 	constexpr size_t NEXT = Op::SIZE;
 	const ExtType npos = last;
-	const size_t pos = mIndPtr->getMeta( mOp.get( npos ) );
+	const size_t pos = mIndPtr->posAt( mOp.get( npos ) );
 	const size_t mnpos = PosForward<ForType::DEFAULT>::value(mlast, mMax, pos);
 	mExpr(mnpos, Getter<NEXT>::template getX<ExtType>( npos ) );
     }
 
-    template <class MapF, class Expr>
-    inline void OpExpr<MapF,Expr>::operator()(size_t mlast) const
+    template <class MapF, class IndexPack, class Expr>
+    inline void OpExpr<MapF,IndexPack,Expr>::operator()(size_t mlast) const
     {
 	const ExtType last;
 	constexpr size_t NEXT = Op::SIZE;
 	const ExtType npos = last;
-	const size_t pos = mIndPtr->at( mOp.get( npos ) ).pos();
+	const size_t pos = mIndPtr->posAt( mOp.get( npos ) );
 	const size_t mnpos = PosForward<ForType::DEFAULT>::value(mlast, mMax, pos);
 	mExpr(mnpos, Getter<NEXT>::template getX<ExtType>( npos ));
     }
     
-    template <class MapF, class Expr>
-    auto OpExpr<MapF,Expr>::rootSteps(std::intptr_t iPtrNum) const
+    template <class MapF, class IndexPack, class Expr>
+    auto OpExpr<MapF,IndexPack,Expr>::rootSteps(std::intptr_t iPtrNum) const
 	-> ExtType
     {
 	return mOp.rootSteps(iPtrNum).extend( mExpr.rootSteps(iPtrNum) );
@@ -364,7 +372,8 @@ namespace MultiArrayTools
 	IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
 	std::get<sizeof...(Indices)>(mBlockSizes) = 1;
 	RPackNum<sizeof...(Indices)-1>::initBlockSizes(mBlockSizes, mIPack); // has one more element!
-	mOutIndex = std::dynamic_pointer_cast<OIType>( IB::mRangePtr )->outRange()->begin();
+	mOutIndex = std::make_shared<OIType>
+	    ( std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->outRange()->begin() );
     }
 
     template <class MapF, class... Indices>
@@ -484,26 +493,26 @@ namespace MultiArrayTools
     }
 
     template <class MapF, class... Indices>
-    size_t MapIndex<MapF,Indices...>::dim()
+    size_t MapIndex<MapF,Indices...>::dim() const
     {
 	return sizeof...(Indices);
     }
 
     template <class MapF, class... Indices>
-    bool MapIndex<MapF,Indices...>::first()
+    bool MapIndex<MapF,Indices...>::first() const
     {
 	return IB::mPos == 0;
     }
 
     template <class MapF, class... Indices>
-    bool MapIndex<MapF,Indices...>::last()
+    bool MapIndex<MapF,Indices...>::last() const
     {
 	return IB::mPos == IB::mMax - 1;
     }
 
     template <class MapF, class... Indices>
     std::shared_ptr<typename MapIndex<MapF,Indices...>::RangeType>
-    MapIndex<MapF,Indices...>::range()
+    MapIndex<MapF,Indices...>::range() const
     {
 	return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
     }
@@ -516,7 +525,7 @@ namespace MultiArrayTools
     }
 
     template <class MapF, class... Indices>	
-    size_t MapIndex<MapF,Indices...>::getStepSize(size_t n)
+    size_t MapIndex<MapF,Indices...>::getStepSize(size_t n) const
     {
 	if(n >= sizeof...(Indices)){
 	    assert(0);
@@ -532,7 +541,7 @@ namespace MultiArrayTools
     }
 
     template <class MapF, class... Indices>
-    void MapIndex<MapF,Indices...>::print(size_t offset)
+    void MapIndex<MapF,Indices...>::print(size_t offset) const
     {
 	if(offset == 0){
 	    std::cout << " === " << std::endl;
@@ -546,11 +555,11 @@ namespace MultiArrayTools
     template <class MapF, class... Indices>
     template <class Exprs>
     auto MapIndex<MapF,Indices...>::ifor(Exprs exs) const
-	-> decltype(RPackNum<sizeof...(Indices)-1>::mkFor
-		    (mIPack, OpExpr<MapF,Exprs>( range()->map(), mIPack, mOutIndex, exs ) ) )
+	-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
+		    (mIPack, OpExpr<MapF,IndexPack,Exprs>( range()->map(), mIPack, mOutIndex, exs ) ) )
     {
-	return RPackNum<sizeof...(Indices)-1>::mkFor
-	    (mIPack, OpExpr<MapF,Exprs>( range()->map(), mIPack, mOutIndex, exs ) );
+	return RPackNum<sizeof...(Indices)-1>::mkForh
+	    (mIPack, OpExpr<MapF,IndexPack,Exprs>( range()->map(), mIPack, mOutIndex, exs ) );
     }
     /*
     template <class MapF, class... Indices>
@@ -603,7 +612,7 @@ namespace MultiArrayTools
 	    std::vector<std::intptr_t> pv(sizeof...(Ranges));
 	    RPackNum<sizeof...(Ranges)-1>::RangesToVec(ptp, pv);
 	    pv.push_back( reinterpret_cast<std::intptr_t>
-			  ( &std::dynamic_pointer_cast<oType>( mProd ).mMapf ) );
+			  ( &std::dynamic_pointer_cast<oType>( mProd )->mMapf ) );
 	    MapRangeFactoryProductMap::mAleadyCreated[mProd] = pv;
 	    out = mProd;
 	}
@@ -614,15 +623,36 @@ namespace MultiArrayTools
      *   MapRange   *
      ******************/
 
+    template <class MapF, class... Ranges>
+    void MapRange<MapF,Ranges...>::mkOutRange()
+    {
+	//FunctionalMultiArray<typename MapF::value_type,MapF,Ranges...> fma(mSpace, mMapf);
+	std::map<typename MapF::value_type,size_t> mult;
+	for(auto ii = mMapf.begin(); ii.max() != ii.pos(); ++ii) {
+	    mult[mMapf[ii]]++;
+	}
+	
+	std::vector<typename MapF::value_type> outmeta(mult.size());
+	std::vector<size_t> outmult(mult.size());
+
+	size_t cnt = 0;
+	for(auto& x: mult){
+	    outmeta[cnt] = x.first;
+	    outmult[cnt] = x.second;
+	    ++cnt;
+	}
+
+	ORFType orf(outmeta);
+	mOutRange = std::dynamic_pointer_cast<ORType>( orf.create() );
+	mMapMult = MultiArray<size_t,ORType>( mOutRange, outmult );
+    }
+    
     template <class MapF, class... Ranges>
     MapRange<MapF,Ranges...>::MapRange(const MapF& mapf, const std::shared_ptr<Ranges>&... rs) :
 	mSpace(std::make_tuple(rs...)),
 	mMapf(mapf)
     {
-	std::vector<typename MapF::value_type> outmeta;
-	// set !!!!
-	ORFType orf(outmeta);
-	mOutRange = std::dynamic_pointer_cast<ORType>( orf.create() );
+	mkOutRange();
     }
 
     template <class MapF, class... Ranges>
@@ -630,10 +660,7 @@ namespace MultiArrayTools
 	mSpace( space ),
 	mMapf(mapf)
     {
-	std::vector<typename MapF::value_type> outmeta;
-	// set !!!!
-	ORFType orf(outmeta);
-	mOutRange = std::dynamic_pointer_cast<ORType>( orf.create() );
+	mkOutRange();
     }
 
     template <class MapF, class... Ranges>
@@ -712,7 +739,7 @@ namespace MultiArrayTools
     template <class MapF, class... Ranges>
     typename MapRange<MapF,Ranges...>::IndexType MapRange<MapF,Ranges...>::begin() const
     {
-	MapIndex<typename Ranges::IndexType...>
+	MapIndex<MapF,typename Ranges::IndexType...>
 	    i( std::dynamic_pointer_cast<MapRange<MapF,Ranges...> >
 	       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = 0;
@@ -722,13 +749,20 @@ namespace MultiArrayTools
     template <class MapF, class... Ranges>
     typename MapRange<MapF,Ranges...>::IndexType MapRange<MapF,Ranges...>::end() const
     {
-	MapIndex<typename Ranges::IndexType...>
+	MapIndex<MapF,typename Ranges::IndexType...>
 	    i( std::dynamic_pointer_cast<MapRange<MapF,Ranges...> >
 	       ( std::shared_ptr<RangeBase>( RB::mThis )) );
 	i = size();
 	return i;
     }
 
+    template <class MapF, class... Ranges>
+    auto MapRange<MapF,Ranges...>::mapMultiplicity() const
+	-> const MultiArray<size_t,ORType>&
+    {
+	return mMapMult;
+    }
+    
     template <class MapF, class... Ranges>
     template <class... ERanges>
     auto MapRange<MapF,Ranges...>::cat(const std::shared_ptr<MapRange<ERanges...> >& erange)
diff --git a/src/include/multi_array_base.h b/src/include/multi_array_base.h
index ebc5f92..684dc27 100644
--- a/src/include/multi_array_base.h
+++ b/src/include/multi_array_base.h
@@ -63,8 +63,8 @@ namespace MultiArrayTools
 	operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const;
 
 	template <class... MappedRanges>
-	ConstOperationRoot<T,SRanges...>
-	operator()(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const;
+	ConstOperationRoot<T,MappedRanges...>
+	m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const;
 
 	virtual bool isInit() const;
 
@@ -111,8 +111,12 @@ namespace MultiArrayTools
 	virtual OperationRoot<T,SRanges...> operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds);
 
 	template <class... MappedRanges>
-	ConstOperationRoot<T,SRanges...>
-	operator()(const std::shared_ptr<typename MappedRanges::IndexType>&... inds);
+	OperationRoot<T,MappedRanges...>
+	m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds);
+
+	template <class... MappedRanges>
+	ConstOperationRoot<T,MappedRanges...>
+	m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const;
 
     };
 
@@ -210,12 +214,12 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     template <class... MappedRanges>
-    ConstOperationRoot<T,SRanges...>
-    MultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
+    ConstOperationRoot<T,MappedRanges...>
+    MultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
     {
 	static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
 		      "number of mapped ranges must be equal to number of original ranges");
-	return (*this)(MapResult(inds)...); // NO !!!!!
+	return ConstOperationRoot<T,MappedRanges...>(*this, inds...);
     }
     
     template <typename T, class... SRanges>
@@ -281,12 +285,22 @@ namespace MultiArrayTools
 
     template <typename T, class... SRanges>
     template <class... MappedRanges>
-    ConstOperationRoot<T,SRanges...>
-    MutableMultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename MappedRanges::IndexType>&... inds)
+    OperationRoot<T,MappedRanges...>
+    MutableMultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds)
     {
 	static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
 		      "number of mapped ranges must be equal to number of original ranges");
-	return (*this)(MapResult(inds)...);
+	return OperationRoot<T,MappedRanges...>(*this, inds...);
+    }
+
+    template <typename T, class... SRanges>
+    template <class... MappedRanges>
+    ConstOperationRoot<T,MappedRanges...>
+    MutableMultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
+    {
+	static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
+		      "number of mapped ranges must be equal to number of original ranges");
+	return ConstOperationRoot<T,MappedRanges...>(*this, inds...);
     }
 
 } // end namespace MultiArrayTools
diff --git a/src/include/multi_array_operation.h b/src/include/multi_array_operation.h
index fc0343e..337554e 100644
--- a/src/include/multi_array_operation.h
+++ b/src/include/multi_array_operation.h
@@ -159,7 +159,7 @@ namespace MultiArrayTools
 	//MultiArrayBase<T,Ranges...> const& mArrayRef;
 	const T* mDataPtr;
 	IndexType mIndex;
-	std::shared_ptr<MultiArrayBase<T,Ranges...> > mMaPtr;
+	//std::shared_ptr<MultiArrayBase<T,Ranges...> > mMaPtr;
     };
 
     template <typename T, class Op>
@@ -545,8 +545,8 @@ namespace MultiArrayTools
     ConstOperationRoot(std::shared_ptr<MultiArrayBase<T,Ranges...> > maptr,
 		       const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(maptr->data()),
-	mIndex(maptr->begin()),
-	mMaPtr(maptr)
+	mIndex(maptr->begin())
+	//mMaPtr(maptr)
     {
 	mIndex(indices...);
     }
diff --git a/src/include/ranges/container_range.h b/src/include/ranges/container_range.h
index cda6287..f55983f 100644
--- a/src/include/ranges/container_range.h
+++ b/src/include/ranges/container_range.h
@@ -42,7 +42,8 @@ namespace MultiArrayTools
 	bool mExternControl = false;
 	IndexPack mIPack;
 	std::array<size_t,sizeof...(Indices)+1> mBlockSizes; 
-	const T* mData;
+	const T* mData = nullptr;
+	//const MultiArrayBase<T,typename Indices::RangeType...>* mMa = nullptr;
 	std::intptr_t mObjPtrNum;
 	
     public:
@@ -465,12 +466,14 @@ namespace MultiArrayTools
     template <typename T, class... Indices>
     const T& ContainerIndex<T,Indices...>::operator*() const
     {
+	//return mMa[*this];
 	return mData[IB::mPos];
     }
 
     template <typename T, class... Indices>
     const T* ContainerIndex<T,Indices...>::operator->() const
     {
+	//return &mMa[*this];
 	return &mData[IB::mPos];
     }
 
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index c865fcf..e3d18a0 100644
--- a/src/include/ranges/single_range.h
+++ b/src/include/ranges/single_range.h
@@ -8,7 +8,7 @@
 #include <memory>
 #include <map>
 
-//#include "base_def.h"
+#include "base_def.h"
 //#include "ranges/rpack_num.h"
 #include "ranges/index_base.h"
 #include "ranges/range_base.h"
@@ -57,6 +57,7 @@ namespace MultiArrayTools
 	U meta() const;
 	const U* metaPtr() const;
 	SingleIndex& at(const U& metaPos);
+	size_t posAt(const U& metaPos) const;
 	
 	size_t dim(); // = 1
 	bool last();
@@ -258,6 +259,12 @@ namespace MultiArrayTools
 	return *this;
     }
 
+    template <typename U, SpaceType TYPE>
+    size_t SingleIndex<U,TYPE>::posAt(const U& metaPos) const
+    {
+	return std::dynamic_pointer_cast<SingleRange<U,TYPE> const>( IB::mRangePtr )->getMeta( metaPos );
+    }
+    
     template <typename U, SpaceType TYPE>
     size_t SingleIndex<U,TYPE>::dim() // = 1
     {
@@ -354,7 +361,7 @@ namespace MultiArrayTools
 	mSpace(space)
     {
 	for(size_t i = 0; i != mSpace.size(); ++i){
-	    mMSpace[mSpace[i]] = i; 
+	    mMSpace[mSpace[i]] = i;
 	}
     }
     
diff --git a/src/tests/op_unit_test.cc b/src/tests/op_unit_test.cc
index 7bb1e43..9f86149 100644
--- a/src/tests/op_unit_test.cc
+++ b/src/tests/op_unit_test.cc
@@ -155,6 +155,43 @@ namespace {
 	std::vector<double> v4 = { 1.470, 2.210 };
     };
 
+    class MapTest : public ::testing::Test
+    {
+    protected:
+
+	typedef SingleRangeFactory<size_t,SpaceType::ANY> SRF;
+	typedef SRF::oType SRange;
+
+	typedef FunctionalMultiArray<size_t,plus<size_t>,SRange,SRange> MapF;
+	
+	typedef MapRangeFactory<MapF,SRange,SRange> MpRF;
+	typedef MpRF::oType MpRange;
+
+	typedef MpRange::ORType TRange;
+	
+	MapTest()
+	{
+	    SRF srf1( { 1,  3,  7,  10 } );
+	    SRF srf2( { 2,  6,  8 } );
+
+	    sr1ptr = std::dynamic_pointer_cast<SRange>( srf1.create() );
+	    sr2ptr = std::dynamic_pointer_cast<SRange>( srf2.create() );
+
+	    MapF map(sr1ptr,sr2ptr);
+	    MpRF mprf1( map, sr1ptr, sr2ptr );
+
+	    mpr1ptr = std::dynamic_pointer_cast<MpRange>( mprf1.create() );
+	}
+
+	std::shared_ptr<SRange> sr1ptr;
+	std::shared_ptr<SRange> sr2ptr;
+	std::shared_ptr<MpRange> mpr1ptr;
+	std::vector<double> v1 = { -31.71, -77.16, -18.81,
+				   -67.06, 72.31, -54.48,
+				   -50.91, -11.62, -59.57,
+				   -42.53, 80.41, 6.35 };
+    };
+    
     class OpTest_Performance : public ::testing::Test
     {
     protected:
@@ -277,6 +314,37 @@ namespace {
 	}
     };
 
+
+    TEST_F(MapTest, Exec1)
+    {
+	MultiArray<double,SRange,SRange> ma1(sr1ptr,sr2ptr,v1);
+	MultiArray<double,MpRange> res(mpr1ptr);
+
+	auto ii1 = getIndex( rptr<0>( ma1 ) );
+	auto ii2 = getIndex( rptr<1>( ma1 ) );
+
+	auto jj = getIndex( mpr1ptr );
+	(*jj)(ii1,ii2);
+	
+	res(jj) = ma1(ii1,ii2);
+
+	MultiArray<double,TRange> form = res.format(mpr1ptr->outRange());
+
+	EXPECT_EQ( jj->range()->outRange()->size(), 10 );
+ 	EXPECT_EQ( jj->range()->mapMultiplicity().at(9), 3 );
+	EXPECT_EQ( jj->range()->mapMultiplicity().at(3), 1 );
+
+	EXPECT_EQ( form.at(3), -31.71 );
+	EXPECT_EQ( form.at(7), -77.16 );
+	EXPECT_EQ( form.at(9), -18.81 + 72.31 -50.91 );
+	EXPECT_EQ( form.at(5), -67.06 );
+	EXPECT_EQ( form.at(11), -54.48 );
+	EXPECT_EQ( form.at(13), -11.62 );
+	EXPECT_EQ( form.at(15), -59.57 );
+	EXPECT_EQ( form.at(12), -42.53 );
+	EXPECT_EQ( form.at(16), 80.41 );
+	EXPECT_EQ( form.at(18), 6.35 );
+    }
     
     TEST_F(MetaOp_Test, SimpleCall)
     {