2018-08-07 21:49:21 +02:00
|
|
|
// -*- C++ -*-
|
|
|
|
|
|
|
|
#ifndef __map_range_h__
|
|
|
|
#define __map_range_h__
|
|
|
|
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <tuple>
|
|
|
|
#include <memory>
|
|
|
|
#include <map>
|
|
|
|
|
2018-08-18 16:24:13 +02:00
|
|
|
#include "mbase_def.h"
|
2018-08-07 21:49:21 +02:00
|
|
|
#include "ranges/range_base.h"
|
|
|
|
#include "ranges/index_base.h"
|
|
|
|
|
|
|
|
#include "ranges/rpack_num.h"
|
2018-08-18 16:24:13 +02:00
|
|
|
#include "map_range_factory_product_map.h"
|
2018-08-07 21:49:21 +02:00
|
|
|
#include "ranges/x_to_string.h"
|
|
|
|
#include "ranges/type_map.h"
|
|
|
|
|
2018-08-07 23:15:31 +02:00
|
|
|
#include "xfor/xfor.h"
|
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
using namespace MultiArrayHelper;
|
|
|
|
}
|
2018-08-08 18:20:08 +02:00
|
|
|
|
|
|
|
template <class MA, class... Indices>
|
|
|
|
auto mkMapOp(const MA& ma,
|
|
|
|
const std::tuple<std::shared_ptr<Indices>...>& itp)
|
2018-08-20 17:50:04 +02:00
|
|
|
-> decltype(PackNum<sizeof...(Indices)-1>::mkMapOp(ma, itp))
|
2018-08-08 18:20:08 +02:00
|
|
|
{
|
|
|
|
return PackNum<sizeof...(Indices)-1>::mkMapOp(ma, itp);
|
|
|
|
}
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
template <class MapF, class IndexPack, class Expr>
|
2018-08-08 18:20:08 +02:00
|
|
|
class OpExpr
|
|
|
|
{
|
|
|
|
public:
|
2018-08-18 16:24:13 +02:00
|
|
|
typedef SingleIndex<typename MapF::value_type,SpaceType::ANY> OIType;
|
2018-08-20 17:50:04 +02:00
|
|
|
//typedef typename MapF::IndexPack IndexPack;
|
2018-08-08 18:20:08 +02:00
|
|
|
static constexpr size_t LAYER = Expr::LAYER + 1;
|
|
|
|
static constexpr size_t SIZE = Expr::SIZE;
|
|
|
|
|
|
|
|
private:
|
|
|
|
OpExpr() = default;
|
|
|
|
|
2018-08-18 16:24:13 +02:00
|
|
|
const OIType* mIndPtr;
|
2018-08-08 18:20:08 +02:00
|
|
|
size_t mSPos;
|
|
|
|
size_t mMax;
|
2018-09-17 16:21:23 +02:00
|
|
|
size_t mStep;
|
2018-08-08 18:20:08 +02:00
|
|
|
Expr mExpr;
|
|
|
|
|
|
|
|
typedef decltype(mkMapOp(std::declval<MapF>(), std::declval<IndexPack>())) Op;
|
|
|
|
Op mOp;
|
|
|
|
|
2018-08-18 16:24:13 +02:00
|
|
|
typedef decltype(mOp.rootSteps(std::declval<intptr_t>()).extend( mExpr.rootSteps(std::declval<intptr_t>()) )) ExtType;
|
|
|
|
ExtType mExt;
|
|
|
|
|
2018-08-08 18:20:08 +02:00
|
|
|
public:
|
|
|
|
OpExpr(const OpExpr& in) = default;
|
|
|
|
OpExpr(OpExpr&& in) = default;
|
|
|
|
OpExpr& operator=(const OpExpr& in) = default;
|
|
|
|
OpExpr& operator=(OpExpr&& in) = default;
|
|
|
|
|
2018-09-18 14:30:49 +02:00
|
|
|
OpExpr(const MapF& mapf, const IndexPack& ipack, const std::shared_ptr<OIType>& oind, size_t step, Expr ex);
|
2018-08-08 18:20:08 +02:00
|
|
|
|
|
|
|
inline void operator()(size_t mlast, ExtType last) const;
|
|
|
|
inline void operator()(size_t mlast = 0) const;
|
|
|
|
|
|
|
|
auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
|
|
|
|
|
|
|
|
};
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
class MapIndex : public IndexInterface<MapIndex<MapF,Indices...>,
|
|
|
|
std::tuple<typename Indices::MetaType...> >
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
typedef IndexInterface<MapIndex<MapF,Indices...>,
|
|
|
|
std::tuple<typename Indices::MetaType...> > IB;
|
|
|
|
typedef std::tuple<std::shared_ptr<Indices>...> IndexPack;
|
|
|
|
typedef std::tuple<typename Indices::MetaType...> MetaType;
|
2018-08-20 17:50:04 +02:00
|
|
|
typedef MapRange<MapF,typename Indices::RangeType...> RangeType;
|
2018-08-07 21:49:21 +02:00
|
|
|
typedef MapIndex IType;
|
2018-08-18 16:24:13 +02:00
|
|
|
typedef SingleIndex<typename MapF::value_type,SpaceType::ANY> OIType;
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
static constexpr IndexType sType() { return IndexType::MULTI; }
|
|
|
|
static constexpr size_t sDim() { return sizeof...(Indices); }
|
2018-08-20 17:50:04 +02:00
|
|
|
static constexpr size_t totalDim() { return mkTotalDim<Indices...>(); }
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
static constexpr SpaceType STYPE = SpaceType::ANY;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
IndexPack mIPack;
|
|
|
|
std::array<size_t,sizeof...(Indices)+1> mBlockSizes;
|
|
|
|
std::shared_ptr<OIType> mOutIndex;
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
const IndexPack& pack() const { return mIPack; }
|
|
|
|
|
|
|
|
MapIndex() = delete;
|
|
|
|
|
|
|
|
// NO DEFAULT HERE !!!
|
|
|
|
// ( have to assign sub-indices (ptr!) correctly )
|
|
|
|
//MapIndex(const MapIndex& in);
|
|
|
|
//MapIndex& operator=(const MapIndex& in);
|
|
|
|
|
|
|
|
template <class MRange>
|
|
|
|
MapIndex(const std::shared_ptr<MRange>& range);
|
|
|
|
|
|
|
|
template <size_t DIR>
|
|
|
|
MapIndex& up();
|
|
|
|
|
|
|
|
template <size_t DIR>
|
|
|
|
MapIndex& down();
|
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
auto get() const -> decltype( *std::get<N>( mIPack ) )&;
|
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;
|
|
|
|
|
2018-09-17 11:06:24 +02:00
|
|
|
template <size_t N>
|
|
|
|
size_t getBlockSize() const { return std::get<N>(mBlockSizes); }
|
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
std::shared_ptr<OIType> outIndex() const;
|
|
|
|
|
|
|
|
// raplace instances (in contrast to its analogon in ContainerIndex
|
|
|
|
// MultiIndices CANNOT be influences be its subindices, so there is
|
|
|
|
// NO foreign/external controll)
|
|
|
|
// Do NOT share index instances between two or more MapIndex instances
|
|
|
|
MapIndex& operator()(std::shared_ptr<Indices>&... indices);
|
|
|
|
|
|
|
|
// ==== >>>>> STATIC POLYMORPHISM <<<<< ====
|
|
|
|
|
|
|
|
IndexType type() const;
|
|
|
|
|
|
|
|
MapIndex& operator=(size_t pos);
|
|
|
|
|
|
|
|
MapIndex& operator++();
|
|
|
|
MapIndex& operator--();
|
|
|
|
|
|
|
|
int pp(std::intptr_t idxPtrNum);
|
|
|
|
int mm(std::intptr_t idxPtrNum);
|
|
|
|
|
|
|
|
std::string stringMeta() const;
|
|
|
|
MetaType meta() const;
|
|
|
|
MapIndex& at(const MetaType& metaPos);
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
size_t dim() const;
|
|
|
|
bool first() const;
|
|
|
|
bool last() const;
|
|
|
|
std::shared_ptr<RangeType> range() const;
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
auto getPtr() -> decltype( std::get<N>( mIPack ) )&;
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
size_t getStepSize(size_t n) const;
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
std::string id() const;
|
2018-08-20 17:50:04 +02:00
|
|
|
void print(size_t offset) const;
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
template <class Exprs>
|
2018-09-17 16:21:23 +02:00
|
|
|
auto ifor(size_t step, Exprs exs) const
|
2018-08-20 17:50:04 +02:00
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
|
2018-09-17 16:21:23 +02:00
|
|
|
(step, mIPack, mBlockSizes, OpExpr<MapF,IndexPack,Exprs>( range()->map(), mIPack, mOutIndex, step, exs ) ) );
|
|
|
|
// first step arg not used!
|
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
/*
|
|
|
|
template <class Exprs>
|
|
|
|
auto iforh(Exprs exs) const
|
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs));
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-18 16:24:13 +02:00
|
|
|
auto mapResult/*<MapIndex<MapF,Indices...> >*/(const std::shared_ptr<MapIndex<MapF,Indices...> >& ind)
|
2018-08-07 21:49:21 +02:00
|
|
|
-> decltype(ind->outIndex())
|
|
|
|
{
|
|
|
|
return ind->outIndex();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************
|
|
|
|
* MapRangeFactory *
|
|
|
|
*************************/
|
|
|
|
|
|
|
|
// NOT THREAD SAVE
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
class MapRangeFactory : public RangeFactoryBase
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef MapRange<MapF,Ranges...> oType;
|
|
|
|
|
|
|
|
MapRangeFactory() = delete;
|
2018-08-08 18:20:08 +02:00
|
|
|
MapRangeFactory(const MapF& mapf, const std::shared_ptr<Ranges>&... rs);
|
|
|
|
MapRangeFactory(const MapF& mapf, const typename MapRange<MapF,Ranges...>::Space& space);
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
virtual std::shared_ptr<RangeBase> create() override;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
std::shared_ptr<RangeBase> checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& ptp);
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/******************
|
|
|
|
* MapRange *
|
|
|
|
******************/
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
2018-08-20 17:50:04 +02:00
|
|
|
class MapRange : public RangeInterface<MapIndex<MapF,typename Ranges::IndexType...> >
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef RangeBase RB;
|
|
|
|
typedef std::tuple<std::shared_ptr<Ranges>...> Space;
|
2018-08-20 17:50:04 +02:00
|
|
|
typedef MapIndex<MapF,typename Ranges::IndexType...> IndexType;
|
2018-08-07 21:49:21 +02:00
|
|
|
typedef MapRange RangeType;
|
2018-08-18 16:24:13 +02:00
|
|
|
typedef SingleRange<typename MapF::value_type,SpaceType::ANY> ORType;
|
|
|
|
typedef SingleRangeFactory<typename MapF::value_type,SpaceType::ANY> ORFType;
|
2018-08-07 21:49:21 +02:00
|
|
|
//typedef typename RangeInterface<MapIndex<typename Ranges::IndexType...> >::IndexType IndexType;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
MapRange() = delete;
|
|
|
|
MapRange(const MapRange& in) = delete;
|
|
|
|
MapRange& operator=(const MapRange& in) = delete;
|
|
|
|
|
|
|
|
MapRange(const MapF& mapf, const std::shared_ptr<Ranges>&... rs);
|
|
|
|
MapRange(const MapF& mapf, const Space& space);
|
|
|
|
|
|
|
|
Space mSpace;
|
2018-08-08 18:20:08 +02:00
|
|
|
const MapF& mMapf;
|
2018-08-18 16:24:13 +02:00
|
|
|
std::shared_ptr<ORType> mOutRange;
|
2018-08-20 17:50:04 +02:00
|
|
|
MultiArray<size_t,ORType> mMapMult;
|
2018-08-07 21:49:21 +02:00
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
private:
|
|
|
|
void mkOutRange();
|
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
public:
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
static constexpr size_t sdim = sizeof...(Ranges);
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
auto get() const -> decltype( *std::get<N>( mSpace ) )&;
|
|
|
|
|
|
|
|
template <size_t N>
|
|
|
|
auto getPtr() const -> decltype( std::get<N>( mSpace ) )&;
|
|
|
|
|
2018-08-18 16:24:13 +02:00
|
|
|
std::shared_ptr<ORType> outRange() const;
|
2018-08-08 18:20:08 +02:00
|
|
|
const MapF& map() const;
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
virtual size_t dim() const final;
|
|
|
|
virtual size_t size() const final;
|
|
|
|
|
|
|
|
virtual SpaceType spaceType() const final;
|
|
|
|
|
|
|
|
virtual std::string stringMeta(size_t pos) const final;
|
|
|
|
virtual std::vector<char> data() const final;
|
|
|
|
|
|
|
|
const Space& space() const;
|
|
|
|
|
|
|
|
virtual IndexType begin() const final;
|
|
|
|
virtual IndexType end() const final;
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
const MultiArray<size_t,ORType>& mapMultiplicity() const;
|
2018-09-17 11:06:24 +02:00
|
|
|
MultiArray<size_t,MapRange> explMapMultiplicity() const;
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
template <class... ERanges>
|
|
|
|
auto cat(const std::shared_ptr<MapRange<ERanges...> >& erange)
|
|
|
|
-> std::shared_ptr<MapRange<Ranges...,ERanges...> >;
|
|
|
|
|
|
|
|
friend MapRangeFactory<MapF,Ranges...>;
|
|
|
|
|
|
|
|
static constexpr bool HASMETACONT = false;
|
|
|
|
static constexpr bool defaultable = false;
|
|
|
|
static constexpr size_t ISSTATIC = SubProp<MapF,Ranges...>::ISSTATIC;
|
|
|
|
static constexpr size_t SIZE = SubProp<MapF,Ranges...>::SIZE;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ========================= *
|
|
|
|
* --- TEMPLATE CODE --- *
|
|
|
|
* ========================= */
|
|
|
|
|
|
|
|
namespace MultiArrayTools
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
using namespace MultiArrayHelper;
|
|
|
|
}
|
|
|
|
|
2018-08-08 18:20:08 +02:00
|
|
|
/**************
|
|
|
|
* OpExpr *
|
|
|
|
**************/
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
template <class MapF, class IndexPack, class Expr>
|
|
|
|
OpExpr<MapF,IndexPack,Expr>::OpExpr(const MapF& mapf, const IndexPack& ipack,
|
2018-09-18 14:30:49 +02:00
|
|
|
const std::shared_ptr<OIType>& oind, size_t step, Expr ex) :
|
|
|
|
mIndPtr(oind.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
|
|
|
|
mStep(step), mExpr( std::forward<Expr>(ex) ),
|
2018-08-20 17:50:04 +02:00
|
|
|
mOp(mkMapOp(mapf, ipack)),
|
|
|
|
//mExt(ex.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
|
2018-09-18 14:30:49 +02:00
|
|
|
mExt( mOp.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr ) ).extend
|
|
|
|
( ex.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr ) ) ) )
|
2018-08-08 18:20:08 +02:00
|
|
|
{
|
|
|
|
assert(mIndPtr != nullptr);
|
|
|
|
}
|
2018-09-18 01:44:11 +02:00
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
template <class MapF, class IndexPack, class Expr>
|
|
|
|
inline void OpExpr<MapF,IndexPack,Expr>::operator()(size_t mlast,
|
|
|
|
ExtType last) const
|
2018-08-08 18:20:08 +02:00
|
|
|
{
|
|
|
|
constexpr size_t NEXT = Op::SIZE;
|
2018-09-18 01:44:11 +02:00
|
|
|
const ExtType nxpos = last;
|
|
|
|
const size_t pos = mIndPtr->posAt( mOp.get( nxpos ) );
|
|
|
|
const ExtType npos = last + mExt*pos;
|
2018-09-17 16:34:47 +02:00
|
|
|
const size_t mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
|
2018-08-08 18:20:08 +02:00
|
|
|
mExpr(mnpos, Getter<NEXT>::template getX<ExtType>( npos ) );
|
|
|
|
}
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
template <class MapF, class IndexPack, class Expr>
|
|
|
|
inline void OpExpr<MapF,IndexPack,Expr>::operator()(size_t mlast) const
|
2018-08-08 18:20:08 +02:00
|
|
|
{
|
|
|
|
const ExtType last;
|
|
|
|
constexpr size_t NEXT = Op::SIZE;
|
2018-09-18 01:44:11 +02:00
|
|
|
const ExtType nxpos = last;
|
|
|
|
const size_t pos = mIndPtr->posAt( mOp.get( nxpos ) );
|
|
|
|
const ExtType npos = last + mExt*pos;
|
2018-09-17 16:34:47 +02:00
|
|
|
const size_t mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
|
2018-08-08 18:20:08 +02:00
|
|
|
mExpr(mnpos, Getter<NEXT>::template getX<ExtType>( npos ));
|
|
|
|
}
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
template <class MapF, class IndexPack, class Expr>
|
|
|
|
auto OpExpr<MapF,IndexPack,Expr>::rootSteps(std::intptr_t iPtrNum) const
|
2018-08-08 18:20:08 +02:00
|
|
|
-> ExtType
|
|
|
|
{
|
|
|
|
return mOp.rootSteps(iPtrNum).extend( mExpr.rootSteps(iPtrNum) );
|
2018-09-18 01:44:11 +02:00
|
|
|
//return mExpr.rootSteps(iPtrNum).extend( mOp.rootSteps(iPtrNum) );
|
2018-08-08 18:20:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
// -> define in range_base.cc
|
2018-08-07 23:15:31 +02:00
|
|
|
//std::shared_ptr<RangeFactoryBase> mkMULTI(const char** dp);
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
/******************
|
|
|
|
* MapIndex *
|
|
|
|
******************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>::MapIndex(const MapIndex<MapF,Indices...>& in) :
|
|
|
|
IndexInterface<std::tuple<typename Indices::MetaType...> >(in)
|
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::copy(mIPack, in);
|
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::operator=(const MapIndex<MapF,Indices...>& in)
|
|
|
|
{
|
|
|
|
IndexI::operator=(in);
|
|
|
|
RPackNum<sizeof...(Indices)-1>::copy(mIPack, in);
|
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <class MRange>
|
|
|
|
MapIndex<MapF,Indices...>::MapIndex(const std::shared_ptr<MRange>& range) :
|
|
|
|
IndexInterface<MapIndex<MapF,Indices...>,std::tuple<typename Indices::MetaType...> >(range, 0)
|
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::construct(mIPack, *range);
|
|
|
|
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!
|
2018-08-20 17:50:04 +02:00
|
|
|
mOutIndex = std::make_shared<OIType>
|
|
|
|
( std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->outRange()->begin() );
|
2018-08-07 21:49:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <size_t DIR>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::up()
|
|
|
|
{
|
|
|
|
static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
|
|
|
|
IB::mPos += RPackNum<sizeof...(Indices)-DIR-1>::blockSize( mIPack );
|
|
|
|
RPackNum<DIR>::pp( mIPack );
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <size_t DIR>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::down()
|
|
|
|
{
|
|
|
|
static_assert(DIR < sizeof...(Indices), "DIR exceeds number of sub-indices");
|
|
|
|
IB::mPos -= RPackNum<sizeof...(Indices)-DIR-1>::blockSize( mIPack );
|
|
|
|
RPackNum<DIR>::mm( mIPack );
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <size_t N>
|
|
|
|
auto MapIndex<MapF,Indices...>::get() const -> decltype( *std::get<N>( mIPack ) )&
|
|
|
|
{
|
|
|
|
return *std::get<N>(mIPack);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <size_t N>
|
|
|
|
auto MapIndex<MapF,Indices...>::getPtr() const -> decltype( std::get<N>( mIPack ) )&
|
|
|
|
{
|
|
|
|
return std::get<N>(mIPack);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-18 16:24:13 +02:00
|
|
|
auto MapIndex<MapF,Indices...>::outIndex() const -> std::shared_ptr<OIType>
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
return mOutIndex;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::operator()(std::shared_ptr<Indices>&... indices)
|
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::swapIndices(mIPack, indices...);
|
|
|
|
RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, IB::mPos);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
IndexType MapIndex<MapF,Indices...>::type() const
|
|
|
|
{
|
|
|
|
return IndexType::MULTI;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::operator=(size_t pos)
|
|
|
|
{
|
|
|
|
IB::mPos = pos;
|
|
|
|
RPackNum<sizeof...(Indices)-1>::setIndexPack(mIPack, pos);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::operator++()
|
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::pp( mIPack );
|
|
|
|
++IB::mPos;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::operator--()
|
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::mm( mIPack );
|
|
|
|
--IB::mPos;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
int MapIndex<MapF,Indices...>::pp(std::intptr_t idxPtrNum)
|
|
|
|
{
|
|
|
|
int tmp = RPackNum<sizeof...(Indices)-1>::pp(mIPack, mBlockSizes, idxPtrNum);
|
|
|
|
IB::mPos += tmp;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
int MapIndex<MapF,Indices...>::mm(std::intptr_t idxPtrNum)
|
|
|
|
{
|
|
|
|
int tmp = RPackNum<sizeof...(Indices)-1>::mm(mIPack, mBlockSizes, idxPtrNum);
|
|
|
|
IB::mPos -= tmp;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
std::string MapIndex<MapF,Indices...>::stringMeta() const
|
|
|
|
{
|
|
|
|
return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr )->stringMeta(IB::mPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
typename MapIndex<MapF,Indices...>::MetaType MapIndex<MapF,Indices...>::meta() const
|
|
|
|
{
|
|
|
|
MetaType metaTuple;
|
|
|
|
RPackNum<sizeof...(Indices)-1>::getMetaPos(metaTuple, mIPack);
|
|
|
|
return metaTuple;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
MapIndex<MapF,Indices...>& MapIndex<MapF,Indices...>::at(const MetaType& metaPos)
|
|
|
|
{
|
|
|
|
RPackNum<sizeof...(Indices)-1>::setMeta(mIPack, metaPos);
|
|
|
|
IB::mPos = RPackNum<sizeof...(Indices)-1>::makePos(mIPack);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-20 17:50:04 +02:00
|
|
|
size_t MapIndex<MapF,Indices...>::dim() const
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
return sizeof...(Indices);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-20 17:50:04 +02:00
|
|
|
bool MapIndex<MapF,Indices...>::first() const
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
return IB::mPos == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-20 17:50:04 +02:00
|
|
|
bool MapIndex<MapF,Indices...>::last() const
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
return IB::mPos == IB::mMax - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
std::shared_ptr<typename MapIndex<MapF,Indices...>::RangeType>
|
2018-08-20 17:50:04 +02:00
|
|
|
MapIndex<MapF,Indices...>::range() const
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
return std::dynamic_pointer_cast<RangeType>( IB::mRangePtr );
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <size_t N>
|
|
|
|
auto MapIndex<MapF,Indices...>::getPtr() -> decltype( std::get<N>( mIPack ) )&
|
|
|
|
{
|
|
|
|
return std::get<N>(mIPack);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-20 17:50:04 +02:00
|
|
|
size_t MapIndex<MapF,Indices...>::getStepSize(size_t n) const
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
if(n >= sizeof...(Indices)){
|
|
|
|
assert(0);
|
|
|
|
// throw !!
|
|
|
|
}
|
|
|
|
return mBlockSizes[n+1];
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
std::string MapIndex<MapF,Indices...>::id() const
|
|
|
|
{
|
|
|
|
return std::string("mul") + std::to_string(IB::mId);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
2018-08-20 17:50:04 +02:00
|
|
|
void MapIndex<MapF,Indices...>::print(size_t offset) const
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
if(offset == 0){
|
|
|
|
std::cout << " === " << std::endl;
|
|
|
|
}
|
|
|
|
for(size_t j = 0; j != offset; ++j) { std::cout << "\t"; }
|
|
|
|
std::cout << id() << "[" << reinterpret_cast<std::intptr_t>(this)
|
|
|
|
<< "]" << "(" << IB::mRangePtr << "): " << meta() << std::endl;
|
|
|
|
RPackNum<sizeof...(Indices)-1>::printIndex(mIPack, offset+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <class Exprs>
|
2018-09-17 16:21:23 +02:00
|
|
|
auto MapIndex<MapF,Indices...>::ifor(size_t step, Exprs exs) const
|
2018-08-20 17:50:04 +02:00
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh
|
2018-09-18 14:30:49 +02:00
|
|
|
(step, mIPack, mBlockSizes, OpExpr<MapF,IndexPack,Exprs>
|
|
|
|
( range()->map(), mIPack, mOutIndex, step, exs ) ) )
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
return RPackNum<sizeof...(Indices)-1>::mkForh
|
2018-09-18 14:30:49 +02:00
|
|
|
(step, mIPack, mBlockSizes, OpExpr<MapF,IndexPack,Exprs>
|
|
|
|
( range()->map(), mIPack, mOutIndex, step, exs ) );
|
2018-08-07 21:49:21 +02:00
|
|
|
}
|
2018-08-08 18:20:08 +02:00
|
|
|
/*
|
2018-08-07 21:49:21 +02:00
|
|
|
template <class MapF, class... Indices>
|
|
|
|
template <class Exprs>
|
|
|
|
auto MapIndex<MapF,Indices...>::iforh(Exprs exs) const
|
|
|
|
-> decltype(RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs))
|
|
|
|
{
|
|
|
|
return RPackNum<sizeof...(Indices)-1>::mkForh(mIPack, exs);
|
|
|
|
}
|
2018-08-08 18:20:08 +02:00
|
|
|
*/
|
2018-08-07 21:49:21 +02:00
|
|
|
/*************************
|
|
|
|
* MapRangeFactory *
|
|
|
|
*************************/
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
2018-08-08 18:20:08 +02:00
|
|
|
MapRangeFactory<MapF,Ranges...>::MapRangeFactory(const MapF& mapf, const std::shared_ptr<Ranges>&... rs)
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
2018-08-08 18:20:08 +02:00
|
|
|
mProd = std::shared_ptr< MapRange<MapF,Ranges...> >( new MapRange<MapF,Ranges...>( mapf, rs... ) );
|
2018-08-07 21:49:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
2018-08-08 18:20:08 +02:00
|
|
|
MapRangeFactory<MapF,Ranges...>::MapRangeFactory(const MapF& mapf, const typename MapRange<MapF,Ranges...>::Space& st)
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
2018-08-08 18:20:08 +02:00
|
|
|
mProd = std::shared_ptr< MapRange<MapF,Ranges...> >( new MapRange<MapF,Ranges...>( mapf, st ) );
|
2018-08-07 21:49:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
std::shared_ptr<RangeBase> MapRangeFactory<MapF,Ranges...>::create()
|
|
|
|
{
|
|
|
|
mProd = checkIfCreated( std::dynamic_pointer_cast<oType>( mProd )->mSpace );
|
|
|
|
setSelf();
|
|
|
|
return mProd;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
std::shared_ptr<RangeBase> MapRangeFactory<MapF,Ranges...>::checkIfCreated(const std::tuple<std::shared_ptr<Ranges>...>& ptp)
|
|
|
|
{
|
|
|
|
std::shared_ptr<RangeBase> out;
|
|
|
|
bool check = false;
|
|
|
|
for(auto& x: MapRangeFactoryProductMap::mAleadyCreated){
|
|
|
|
if(x.second.size() == sizeof...(Ranges)){
|
|
|
|
check = RPackNum<sizeof...(Ranges)-1>::checkIfCreated(ptp, x.second);
|
|
|
|
if(check){
|
|
|
|
out = x.first;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(not check){
|
|
|
|
std::vector<std::intptr_t> pv(sizeof...(Ranges));
|
|
|
|
RPackNum<sizeof...(Ranges)-1>::RangesToVec(ptp, pv);
|
2018-08-18 16:24:13 +02:00
|
|
|
pv.push_back( reinterpret_cast<std::intptr_t>
|
2018-08-20 17:50:04 +02:00
|
|
|
( &std::dynamic_pointer_cast<oType>( mProd )->mMapf ) );
|
2018-08-07 21:49:21 +02:00
|
|
|
MapRangeFactoryProductMap::mAleadyCreated[mProd] = pv;
|
|
|
|
out = mProd;
|
|
|
|
}
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************
|
|
|
|
* MapRange *
|
|
|
|
******************/
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
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 );
|
|
|
|
}
|
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
template <class MapF, class... Ranges>
|
2018-08-08 18:20:08 +02:00
|
|
|
MapRange<MapF,Ranges...>::MapRange(const MapF& mapf, const std::shared_ptr<Ranges>&... rs) :
|
|
|
|
mSpace(std::make_tuple(rs...)),
|
|
|
|
mMapf(mapf)
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
mkOutRange();
|
2018-08-07 21:49:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
2018-08-08 18:20:08 +02:00
|
|
|
MapRange<MapF,Ranges...>::MapRange(const MapF& mapf, const Space& space) :
|
|
|
|
mSpace( space ),
|
|
|
|
mMapf(mapf)
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
mkOutRange();
|
2018-08-07 21:49:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
template <size_t N>
|
|
|
|
auto MapRange<MapF,Ranges...>::get() const -> decltype( *std::get<N>( mSpace ) )&
|
|
|
|
{
|
|
|
|
return *std::get<N>(mSpace);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
template <size_t N>
|
|
|
|
auto MapRange<MapF,Ranges...>::getPtr() const -> decltype( std::get<N>( mSpace ) )&
|
|
|
|
{
|
|
|
|
return std::get<N>(mSpace);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
2018-08-18 16:24:13 +02:00
|
|
|
auto MapRange<MapF,Ranges...>::outRange() const -> std::shared_ptr<ORType>
|
2018-08-07 21:49:21 +02:00
|
|
|
{
|
|
|
|
return mOutRange;
|
|
|
|
}
|
2018-08-08 18:20:08 +02:00
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
2018-08-18 16:24:13 +02:00
|
|
|
const MapF& MapRange<MapF,Ranges...>::map() const
|
2018-08-08 18:20:08 +02:00
|
|
|
{
|
|
|
|
return mMapf;
|
|
|
|
}
|
2018-08-07 21:49:21 +02:00
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
size_t MapRange<MapF,Ranges...>::dim() const
|
|
|
|
{
|
|
|
|
return sdim;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
size_t MapRange<MapF,Ranges...>::size() const
|
|
|
|
{
|
|
|
|
return RPackNum<sizeof...(Ranges)-1>::getSize(mSpace);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
SpaceType MapRange<MapF,Ranges...>::spaceType() const
|
|
|
|
{
|
|
|
|
return SpaceType::ANY;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
const typename MapRange<MapF,Ranges...>::Space& MapRange<MapF,Ranges...>::space() const
|
|
|
|
{
|
|
|
|
return mSpace;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
std::string MapRange<MapF,Ranges...>::stringMeta(size_t pos) const
|
|
|
|
{
|
|
|
|
auto i = begin();
|
|
|
|
i = pos;
|
|
|
|
return "[ " + RPackNum<sizeof...(Ranges)-1>::metaTupleToString(i.meta()) + " ]";
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
std::vector<char> MapRange<MapF,Ranges...>::data() const
|
|
|
|
{
|
|
|
|
DataHeader h;
|
|
|
|
h.spaceType = static_cast<int>( SpaceType::ANY );
|
|
|
|
h.metaSize = sizeof...(Ranges);
|
|
|
|
h.multiple = 1;
|
|
|
|
std::vector<char> out;
|
|
|
|
//out.reserve(h.metaSize + sizeof(DataHeader));
|
|
|
|
char* hcp = reinterpret_cast<char*>(&h);
|
|
|
|
out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
|
|
|
|
RPackNum<sizeof...(Ranges)-1>::fillRangeDataVec(out, mSpace);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
typename MapRange<MapF,Ranges...>::IndexType MapRange<MapF,Ranges...>::begin() const
|
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
MapIndex<MapF,typename Ranges::IndexType...>
|
2018-08-07 21:49:21 +02:00
|
|
|
i( std::dynamic_pointer_cast<MapRange<MapF,Ranges...> >
|
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
|
|
|
|
i = 0;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
typename MapRange<MapF,Ranges...>::IndexType MapRange<MapF,Ranges...>::end() const
|
|
|
|
{
|
2018-08-20 17:50:04 +02:00
|
|
|
MapIndex<MapF,typename Ranges::IndexType...>
|
2018-08-07 21:49:21 +02:00
|
|
|
i( std::dynamic_pointer_cast<MapRange<MapF,Ranges...> >
|
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis )) );
|
|
|
|
i = size();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2018-08-20 17:50:04 +02:00
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
auto MapRange<MapF,Ranges...>::mapMultiplicity() const
|
|
|
|
-> const MultiArray<size_t,ORType>&
|
|
|
|
{
|
|
|
|
return mMapMult;
|
|
|
|
}
|
2018-09-17 11:06:24 +02:00
|
|
|
|
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
auto MapRange<MapF,Ranges...>::explMapMultiplicity() const
|
|
|
|
-> MultiArray<size_t,MapRange>
|
|
|
|
{
|
|
|
|
auto tmp = mMapMult;
|
|
|
|
return tmp.format( std::dynamic_pointer_cast<MapRange<MapF,Ranges...> >
|
|
|
|
( std::shared_ptr<RangeBase>( RB::mThis )) );
|
|
|
|
}
|
2018-08-20 17:50:04 +02:00
|
|
|
|
2018-08-07 21:49:21 +02:00
|
|
|
template <class MapF, class... Ranges>
|
|
|
|
template <class... ERanges>
|
|
|
|
auto MapRange<MapF,Ranges...>::cat(const std::shared_ptr<MapRange<ERanges...> >& erange)
|
|
|
|
-> std::shared_ptr<MapRange<Ranges...,ERanges...> >
|
|
|
|
{
|
|
|
|
auto crange = std::tuple_cat(mSpace, erange->space());
|
|
|
|
MapRangeFactory<Ranges...,ERanges...> rf(crange);
|
|
|
|
return std::dynamic_pointer_cast<MapRange<Ranges...,ERanges...> >(rf.create());
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|