various fixes and adds -> map range test works

2018-08-20 17:50:04 +02:00 · 2018-08-20 17:50:04 +02:00 · 9e5c51428a
commit 9e5c51428a
parent 3abdf61c33
8 changed files with 211 additions and 68 deletions
--- 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)
 	{
--- 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
    {
--- 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)
--- 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
--- 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...);
    }
--- 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];
    }

--- 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;
 	}
    }
    
--- 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)
    {