remove old files + first yr_test (to be extended)
This commit is contained in:
Christian Zimmermann
parent
3e54485b12
commit
da4bf39c83
18 changed files with 431 additions and 444 deletions
|
|
@ -11,6 +11,7 @@
|
|||
#include <map>
|
||||
#include <typeinfo>
|
||||
#include <utility>
|
||||
#include <numeric>
|
||||
|
||||
namespace CNORXZ
|
||||
{
|
||||
|
|
@ -20,6 +21,7 @@ namespace CNORXZ
|
|||
|
||||
typedef std::intptr_t PtrId;
|
||||
typedef int32_t Int;
|
||||
typedef int64_t LInt;
|
||||
typedef uint64_t SizeT;
|
||||
typedef double Double;
|
||||
typedef Double Real;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ namespace CNORXZ
|
|||
template <class Xpr, class F>
|
||||
decltype(auto) CIndex::ifor(const Xpr& xpr, F&& f) const
|
||||
{
|
||||
return For<0,Xpr,F>(this->max(), this->id(), xpr, std::forward<F>(f));
|
||||
return For<0,Xpr,F>(this->pmax(), this->id(), xpr, std::forward<F>(f));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ namespace CNORXZ
|
|||
|
||||
CIndex(const RangePtr& range, SizeT pos = 0);
|
||||
|
||||
CIndex& operator=(SizeT pos);
|
||||
CIndex& operator=(SizeT lexpos);
|
||||
CIndex& operator++();
|
||||
CIndex& operator--();
|
||||
CIndex operator+(Int n) const;
|
||||
|
|
@ -27,7 +27,9 @@ namespace CNORXZ
|
|||
CIndex& operator+=(Int n);
|
||||
CIndex& operator-=(Int n);
|
||||
|
||||
SizeT max() const;
|
||||
SizeT lex() const;
|
||||
SizeT pmax() const;
|
||||
SizeT lmax() const;
|
||||
IndexId<0> id() const;
|
||||
|
||||
SizeT operator*() const;
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ namespace CNORXZ
|
|||
template <class Index, typename Meta>
|
||||
DIndex(const IndexInterface<Index,Meta>& i);
|
||||
|
||||
DIndex& operator=(SizeT pos);
|
||||
DIndex& operator=(SizeT lexpos);
|
||||
DIndex& operator++();
|
||||
DIndex& operator--();
|
||||
DIndex operator+(Int n) const;
|
||||
|
|
@ -32,7 +32,9 @@ namespace CNORXZ
|
|||
DIndex& operator+=(Int n);
|
||||
DIndex& operator-=(Int n);
|
||||
|
||||
SizeT max() const;
|
||||
SizeT lex() const;
|
||||
SizeT pmax() const;
|
||||
SizeT lmax() const;
|
||||
IndexId<0> id() const;
|
||||
|
||||
DType operator*() const;
|
||||
|
|
@ -48,6 +50,8 @@ namespace CNORXZ
|
|||
|
||||
DXpr<SizeT> ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const;
|
||||
|
||||
const XIndexPtr& xptr() const;
|
||||
|
||||
private:
|
||||
XIndexPtr mI;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -20,17 +20,18 @@ namespace CNORXZ
|
|||
I& THIS() { return static_cast<I&>(*this); }
|
||||
const I& THIS() const { return static_cast<const I&>(*this); }
|
||||
|
||||
I& operator=(SizeT pos) { return THIS() = pos; }
|
||||
I& operator++() { return ++THIS(); }
|
||||
I& operator--() { return --THIS();}
|
||||
I operator+(Int n) const { return THIS() + n; }
|
||||
I operator-(Int n) const { return THIS() - n; }
|
||||
I& operator+=(Int n) { return THIS() += n; }
|
||||
I& operator-=(Int n) { return THIS() -= n; }
|
||||
Int operator-(const IndexInterface& i) const { return mPos - i.mPos; }
|
||||
Int operator-(const IndexInterface& i) const { return lex() - i.lex(); }
|
||||
|
||||
SizeT pos() const;
|
||||
SizeT max() const { return THIS().max(); }
|
||||
SizeT pos() const; // 'memory' pos
|
||||
SizeT lex() const { return THIS().lex(); } // lexicographic pos
|
||||
SizeT pmax() const { return THIS().pmax(); } // memory pos max
|
||||
SizeT lmax() const { return THIS().lmax(); } // lexicographic pos max
|
||||
PtrId ptrId() const;
|
||||
decltype(auto) id() const { return THIS().id(); }
|
||||
|
||||
|
|
|
|||
|
|
@ -12,12 +12,12 @@ namespace CNORXZ
|
|||
|
||||
template <class... Indices>
|
||||
template <SizeT... Is>
|
||||
constexpr decltype(auto) MIndex<Indices...>::mkIPack(SizeT pos, Isq<Is...> is) const
|
||||
constexpr decltype(auto) MIndex<Indices...>::mkIPack(Isq<Is...> is) const
|
||||
{
|
||||
static_assert(sizeof...(Is) == NI,
|
||||
"sequence size does not match number of indices");
|
||||
"sequence sioze does not match number of indices");
|
||||
CXZ_ASSERT( ( (mRange->sub(Is) != nullptr) and ... ),
|
||||
"no subranges available" );
|
||||
"subranges not available" );
|
||||
return std::make_tuple( std::make_shared<Indices>( mRange->sub(Is) )... );
|
||||
}
|
||||
|
||||
|
|
@ -28,7 +28,7 @@ namespace CNORXZ
|
|||
return std::make_tuple
|
||||
( iter<Is,NI>
|
||||
// replace UPos by SPos where possible !!!
|
||||
( [&](auto i) { return UPos(std::get<i>(ipack)->max()); },
|
||||
( [&](auto i) { return UPos(std::get<i>(ipack)->pmax()); },
|
||||
[&](const auto&... as) { return (as * ...); } )...,
|
||||
SPos<1>() );
|
||||
}
|
||||
|
|
@ -39,7 +39,7 @@ namespace CNORXZ
|
|||
{
|
||||
auto& i = std::get<I>(mIPack);
|
||||
if constexpr(I != 0){
|
||||
if(i->pos() == i->max()-1){
|
||||
if(i->lex() == i->lmax()-1){
|
||||
IB::mPos -= std::get<I>(mBlockSizes).val() * i->pos();
|
||||
(*i) = 0;
|
||||
up<I-1>();
|
||||
|
|
@ -56,8 +56,8 @@ namespace CNORXZ
|
|||
{
|
||||
auto& i = std::get<I>(mIPack);
|
||||
if constexpr(I != 0){
|
||||
if(i->pos() == 0){
|
||||
(*i) = i->max()-1;
|
||||
if(i->lex() == 0){
|
||||
(*i) = i->lmax()-1;
|
||||
IB::mPos += std::get<I>(mBlockSizes).val() * i->pos();
|
||||
down<I-1>();
|
||||
return;
|
||||
|
|
@ -85,37 +85,46 @@ namespace CNORXZ
|
|||
|
||||
template <class... Indices>
|
||||
MIndex<Indices...>::MIndex(const MIndex& i) :
|
||||
IndexInterface<MIndex<Indices...>,Tuple<typename Indices::MetaType...>>(i.pos()),
|
||||
IndexInterface<MIndex<Indices...>,Tuple<typename Indices::MetaType...>>(0),
|
||||
mRange(rangeCast<RangeType>(i.range())),
|
||||
mIPack(mkIPack(IB::mPos, Isqr<0,NI>{})),
|
||||
mIPack(mkIPack(Isqr<0,NI>{})),
|
||||
mBlockSizes(mkBlockSizes(mIPack,Isqr<0,NI-1>{}))
|
||||
{}
|
||||
{
|
||||
mPMax = iter<0,NI>( [&](auto i) { return std::get<i>(mIPack)->pmax(); },
|
||||
[](auto... e) { return (e * ...); });
|
||||
*this = i.pos();
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MIndex<Indices...>& MIndex<Indices...>::operator=(const MIndex& i)
|
||||
{
|
||||
IndexInterface<MIndex<Indices...>,Tuple<typename Indices::MetaType...>>::operator=(i);
|
||||
IndexInterface<MIndex<Indices...>,Tuple<typename Indices::MetaType...>>::operator=(0);
|
||||
mRange = rangeCast<RangeType>(i.range());
|
||||
mIPack = mkIPack(IB::mPos, Isqr<0,NI>{});
|
||||
mIPack = mkIPack(Isqr<0,NI>{});
|
||||
mBlockSizes = mkBlockSizes(mIPack,Isqr<0,NI-1>{});
|
||||
return *this;
|
||||
mPMax = iter<0,NI>( [&](auto i) { return std::get<i>(mIPack)->pmax(); },
|
||||
[](auto... e) { return (e * ...); });
|
||||
return *this = i.pos();
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MIndex<Indices...>::MIndex(const RangePtr& range, SizeT pos) :
|
||||
MIndex<Indices...>::MIndex(const RangePtr& range, SizeT lexpos) :
|
||||
IndexInterface<MIndex<Indices...>,Tuple<typename Indices::MetaType...>>(0),
|
||||
mRange(rangeCast<RangeType>(range)),
|
||||
mIPack(mkIPack(IB::mPos, Isqr<0,NI>{})),
|
||||
mIPack(mkIPack(Isqr<0,NI>{})),
|
||||
mBlockSizes(mkBlockSizes(mIPack,Isqr<0,NI-1>{}))
|
||||
{
|
||||
(*this) = pos;
|
||||
mPMax = iter<0,NI>( [&](auto i) { return std::get<i>(mIPack)->pmax(); },
|
||||
[](auto... e) { return (e * ...); });
|
||||
*this = lexpos;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
MIndex<Indices...>& MIndex<Indices...>::operator=(SizeT pos)
|
||||
MIndex<Indices...>& MIndex<Indices...>::operator=(SizeT lexpos)
|
||||
{
|
||||
IB::mPos = pos;
|
||||
iter<0,NI>( [&](auto i) { *std::get<i>(mIPack) = (IB::mPos / std::get<i>(mBlockSizes).val()) % std::get<i>(mIPack)->max(); }, NoF{} );
|
||||
// Adapt in GMIndex
|
||||
IB::mPos = lexpos;
|
||||
iter<0,NI>( [&](auto i) { *std::get<i>(mIPack) = (IB::mPos / std::get<i>(mBlockSizes).val()) % std::get<i>(mIPack)->pmax(); }, NoF{} );
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -123,8 +132,7 @@ namespace CNORXZ
|
|||
MIndex<Indices...>& MIndex<Indices...>::operator++()
|
||||
{
|
||||
// End state is defined by high-index being end while all other indices are zero
|
||||
auto& i0 = std::get<0>(mIPack);
|
||||
if(i0->pos() != i0->max()){
|
||||
if(lex() != lmax()){
|
||||
up<NI-1>();
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -133,7 +141,7 @@ namespace CNORXZ
|
|||
template <class... Indices>
|
||||
MIndex<Indices...>& MIndex<Indices...>::operator--()
|
||||
{
|
||||
if(IB::mPos != 0){
|
||||
if(lex() != 0){
|
||||
down<NI-1>();
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -156,12 +164,12 @@ namespace CNORXZ
|
|||
template <class... Indices>
|
||||
MIndex<Indices...>& MIndex<Indices...>::operator+=(Int n)
|
||||
{
|
||||
if(-n > static_cast<long int>(IB::mPos)){
|
||||
if(-n > static_cast<long int>(lex())){
|
||||
(*this) = 0;
|
||||
}
|
||||
const SizeT p = IB::mPos + n;
|
||||
if(p > max()){
|
||||
(*this) = max();
|
||||
const SizeT p = lex() + n;
|
||||
if(p > lmax()){
|
||||
(*this) = lmax();
|
||||
}
|
||||
(*this) = p;
|
||||
return *this;
|
||||
|
|
@ -170,21 +178,33 @@ namespace CNORXZ
|
|||
template <class... Indices>
|
||||
MIndex<Indices...>& MIndex<Indices...>::operator-=(Int n)
|
||||
{
|
||||
if(n > static_cast<long int>(IB::mPos)){
|
||||
if(n > static_cast<long int>(lex())){
|
||||
(*this) = 0;
|
||||
}
|
||||
const SizeT p = IB::mPos + n;
|
||||
if(p > max()){
|
||||
(*this) = max();
|
||||
const SizeT p = lex() + n;
|
||||
if(p > lmax()){
|
||||
(*this) = lmax();
|
||||
}
|
||||
(*this) = p;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
SizeT MIndex<Indices...>::max() const
|
||||
SizeT MIndex<Indices...>::lex() const
|
||||
{
|
||||
return mRange->size();
|
||||
return IB::mPos;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
SizeT MIndex<Indices...>::pmax() const
|
||||
{
|
||||
return mPMax;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
SizeT MIndex<Indices...>::lmax() const
|
||||
{
|
||||
return mPMax;
|
||||
}
|
||||
|
||||
template <class... Indices>
|
||||
|
|
|
|||
|
|
@ -27,12 +27,13 @@ namespace CNORXZ
|
|||
// NO DEFAULT HERE !!!
|
||||
// ( have to assign sub-indices (ptr!) correctly )
|
||||
MIndex() = default;
|
||||
MIndex(const MIndex& i);
|
||||
MIndex& operator=(const MIndex& i);
|
||||
MIndex(MIndex&& i) = default;
|
||||
MIndex& operator=(MIndex&& i) = default;
|
||||
|
||||
MIndex(const RangePtr& range, SizeT pos = 0);
|
||||
MIndex(const MIndex& i);
|
||||
MIndex& operator=(const MIndex& i);
|
||||
|
||||
MIndex(const RangePtr& range, SizeT lexpos = 0);
|
||||
|
||||
MIndex& operator=(SizeT pos);
|
||||
MIndex& operator++();
|
||||
|
|
@ -42,7 +43,9 @@ namespace CNORXZ
|
|||
MIndex& operator+=(Int n);
|
||||
MIndex& operator-=(Int n);
|
||||
|
||||
SizeT max() const;
|
||||
SizeT lex() const;
|
||||
SizeT pmax() const;
|
||||
SizeT lmax() const;
|
||||
IndexId<0> id() const;
|
||||
|
||||
MetaType operator*() const;
|
||||
|
|
@ -71,7 +74,7 @@ namespace CNORXZ
|
|||
static constexpr decltype(auto) mkBlockSizes(const IndexPack& ipack, Isq<Is...> is);
|
||||
|
||||
template <SizeT... Is>
|
||||
constexpr decltype(auto) mkIPack(SizeT pos, Isq<Is...> is) const;
|
||||
constexpr decltype(auto) mkIPack(Isq<Is...> is) const;
|
||||
|
||||
template <SizeT I>
|
||||
inline void up();
|
||||
|
|
@ -86,6 +89,7 @@ namespace CNORXZ
|
|||
IndexPack mIPack;
|
||||
typedef RemoveRef<decltype(mkBlockSizes(mIPack,Isqr<0,NI-1>{}))> BlockTuple;
|
||||
BlockTuple mBlockSizes;
|
||||
SizeT mPMax = 0; // = LMax here, add new variable in GMIndex!
|
||||
};
|
||||
|
||||
// modified blockSizes; to be used for Slices; can be created from MIndices
|
||||
|
|
@ -101,7 +105,7 @@ namespace CNORXZ
|
|||
constexpr decltype(auto) ifor(const Xpr& xpr, F&& f) const;
|
||||
|
||||
private:
|
||||
BlockType mBlockSizes;
|
||||
BlockType mLexBlockSizes;
|
||||
|
||||
template <SizeT... Is>
|
||||
constexpr decltype(auto) mkPos(Isq<Is...> is) const;
|
||||
|
|
|
|||
|
|
@ -1,285 +0,0 @@
|
|||
|
||||
#ifndef __cxz_range_helper_h__
|
||||
#define __cxz_range_helper_h__
|
||||
|
||||
namespace CNORXZ
|
||||
{
|
||||
namespace RangeHelper
|
||||
{
|
||||
|
||||
template <size_t I, class... Indices>
|
||||
int ppx(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
std::array<size_t,sizeof...(Indices)+1>& bs,
|
||||
std::intptr_t idxPtrNum)
|
||||
{
|
||||
auto& siPtr = std::get<I>(ip);
|
||||
if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
|
||||
if constexpr(I != 0){
|
||||
return ppx<I-1>(ip, bs, idxPtrNum);
|
||||
}
|
||||
else {
|
||||
return std::get<0>(bs);
|
||||
}
|
||||
}
|
||||
else {
|
||||
const int tmp = siPtr->pp(idxPtrNum);
|
||||
if constexpr(I != 0){
|
||||
if(siPtr->pos() == siPtr->max()){
|
||||
(*siPtr) = 0;
|
||||
return ppx<I-1>(ip, bs, idxPtrNum) - siPtr->max() + 1;
|
||||
}
|
||||
}
|
||||
return tmp * std::get<I+1>(bs);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t I, class... Indices>
|
||||
int mmx(std::tuple<std::shared_ptr<Indices>...>& ip,
|
||||
std::array<size_t,sizeof...(Indices)+1>& bs,
|
||||
std::intptr_t idxPtrNum)
|
||||
{
|
||||
auto& siPtr = std::get<I>(ip);
|
||||
if(reinterpret_cast<std::intptr_t>(siPtr.get()) == idxPtrNum){
|
||||
if constexpr(I != 0){
|
||||
return mmx<I-1>(ip, bs, idxPtrNum);
|
||||
}
|
||||
else {
|
||||
return std::get<0>(bs);
|
||||
}
|
||||
}
|
||||
else {
|
||||
const int tmp = siPtr->mm(idxPtrNum);
|
||||
if constexpr(I != 0){
|
||||
if(siPtr->pos() == siPtr->max()){
|
||||
(*siPtr) = siPtr->max() - 1;
|
||||
return mmx<I-1>(ip, bs, idxPtrNum) - siPtr->max() + 1;
|
||||
}
|
||||
}
|
||||
return tmp * std::get<I+1>(bs);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class... Indices>
|
||||
inline size_t makePos(const std::tuple<std::shared_ptr<Indices>...>& iPtrTup,
|
||||
const std::array<size_t,sizeof...(Indices)+1>& blockSize)
|
||||
{
|
||||
if constexpr(N != 0){
|
||||
return makePos<N-1>(iPtrTup, blockSize) +
|
||||
std::get<N>(iPtrTup)->pos() * std::get<N+1>(blockSize);
|
||||
}
|
||||
else {
|
||||
return std::get<0>(iPtrTup)->pos() * std::get<1>(blockSize);
|
||||
}
|
||||
}
|
||||
|
||||
template <class Range>
|
||||
inline void resolveSetRange(std::shared_ptr<Range>& rp, const vector<std::shared_ptr<RangeBase> >& orig,
|
||||
size_t origpos, size_t size)
|
||||
{
|
||||
assert(size == 1);
|
||||
rp = std::dynamic_pointer_cast<Range>( orig[origpos] ); // catch bad cast here!!
|
||||
}
|
||||
|
||||
template <class Range>
|
||||
inline void setRangeToVec(vector<std::shared_ptr<RangeBase> >& v,
|
||||
std::shared_ptr<Range> r)
|
||||
{
|
||||
v.insert(v.begin(), r);
|
||||
}
|
||||
|
||||
template <size_t N, class IndexPack>
|
||||
void setIndexPack(IndexPack& iPack, size_t pos)
|
||||
{
|
||||
auto& i = *std::get<N>(iPack).get();
|
||||
const size_t ownPos = pos % i.max();
|
||||
i = ownPos;
|
||||
if constexpr(N != 0){
|
||||
setIndexPack<N-1>(iPack, (pos - ownPos) / i.max() );
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class... Ranges>
|
||||
inline size_t getMeta(const std::tuple<std::shared_ptr<Ranges>...>& space,
|
||||
const std::tuple<typename Ranges::IndexType::MetaType...>& meta)
|
||||
{
|
||||
if constexpr(N != 0){
|
||||
return getMeta<N-1>(space,meta) * std::get<N>(space)->size() +
|
||||
std::get<N>(space)->getMeta(std::get<N>(meta));
|
||||
}
|
||||
else {
|
||||
return std::get<0>(space)->getMeta(std::get<0>(meta));
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class... Ranges>
|
||||
inline void getTypeNum(vector<size_t>& res, const std::tuple<std::shared_ptr<Ranges>...>& stp)
|
||||
{
|
||||
auto& r = *std::get<N>(stp);
|
||||
auto tn = r.typeNum();
|
||||
res.insert(res.begin(), tn.begin(), tn.end());
|
||||
if constexpr(N != 0){
|
||||
getTypeNum<N-1>(res, stp);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class IndexPack, class BlockArray, class Exprs>
|
||||
auto mkFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
|
||||
{
|
||||
constexpr size_t S = std::tuple_size<IndexPack>::value;
|
||||
if constexpr(N < S-1){
|
||||
return std::get<N>(ipack)
|
||||
->ifor( step*std::get<N+1>(ba), mkFor<N+1>(step, ipack, ba, exs) );
|
||||
}
|
||||
else {
|
||||
return std::get<N>(ipack)->ifor( step*std::get<N+1>(ba), exs);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class IndexPack, class BlockArray, class Exprs>
|
||||
auto mkForh(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
|
||||
{
|
||||
constexpr size_t S = std::tuple_size<IndexPack>::value;
|
||||
if constexpr(N < S-1){
|
||||
return std::get<N>(ipack)
|
||||
->iforh( step*std::get<N+1>(ba), mkForh<N+1>(step, ipack, ba, exs) );
|
||||
}
|
||||
else {
|
||||
return std::get<N>(ipack)->iforh( step*std::get<N+1>(ba), exs);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class IndexPack, class BlockArray, class Exprs>
|
||||
auto mkPFor(size_t step, const IndexPack& ipack, const BlockArray& ba, Exprs exs)
|
||||
{
|
||||
constexpr size_t S = std::tuple_size<IndexPack>::value;
|
||||
if constexpr(N < S-1){
|
||||
return std::get<N>(ipack)
|
||||
->pifor( step*std::get<N+1>(ba), mkFor<N+1>(step, ipack, ba, exs) );
|
||||
// mkFor is correct here, because we want to multithread only the FIRST index!!
|
||||
}
|
||||
else {
|
||||
return std::get<N>(ipack)->pifor( step*std::get<N+1>(ba), exs);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class RangeTuple, typename... SIZET>
|
||||
inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
|
||||
RangeTuple& rtp, size_t off, size_t size, SIZET... sizes)
|
||||
{
|
||||
constexpr size_t tps = std::tuple_size<RangeTuple>::value;
|
||||
::CNORXZ::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
|
||||
if constexpr(N < tps-1){
|
||||
resolveRangeType<N+1>(orig, rtp, off+size, sizes...);
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class RangeTuple>
|
||||
inline void resolveRangeType(const vector<std::shared_ptr<RangeBase> >& orig,
|
||||
RangeTuple& rtp, size_t off, size_t size)
|
||||
{
|
||||
constexpr size_t tps = std::tuple_size<RangeTuple>::value;
|
||||
::CNORXZ::RangeHelper::resolveSetRange(std::get<N>(rtp), orig, off, size);
|
||||
}
|
||||
|
||||
template <size_t N, class MetaType, class... Ranges>
|
||||
inline size_t getCMeta(MetaType* xtarget, size_t pos,
|
||||
const std::tuple<std::shared_ptr<Ranges>...>& stp, size_t off)
|
||||
{
|
||||
//constexpr size_t NN = sizeof...(Ranges);
|
||||
auto& r = *std::get<N>(stp);
|
||||
const size_t ownPos = pos % r.size();
|
||||
const size_t s = r.cmetaSize();
|
||||
off -= s;
|
||||
r.cmeta(reinterpret_cast<char*>(&std::get<N>(*xtarget)), ownPos);
|
||||
if constexpr(N != 0){
|
||||
return s + getCMeta<N-1>(xtarget, (pos - ownPos) / r.size(), stp, off);
|
||||
}
|
||||
else {
|
||||
assert(off == 0);
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class... Ranges>
|
||||
inline size_t getCMetaSize(const std::tuple<std::shared_ptr<Ranges>...>& stp)
|
||||
{
|
||||
auto& r = *std::get<N>(stp);
|
||||
if constexpr(N < sizeof...(Ranges)-1){
|
||||
return r.cmetaSize() + getCMetaSize<N+1>(stp);
|
||||
}
|
||||
else {
|
||||
return r.cmetaSize();
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class MIndex>
|
||||
inline std::string getStringMeta(const MIndex& mi)
|
||||
{
|
||||
if constexpr(N < MIndex::sDim()-1){
|
||||
return mi.template getPtr<N>()->stringMeta() + "," + getStringMeta<N+1>(mi);
|
||||
}
|
||||
else {
|
||||
return mi.template getPtr<N>()->stringMeta();
|
||||
}
|
||||
}
|
||||
|
||||
template <class Index>
|
||||
inline size_t getStepSize(const Index& ii, std::intptr_t j);
|
||||
|
||||
template <size_t N, class Index>
|
||||
inline void getStepSizeX(const Index& ii, std::intptr_t j, size_t& ss, size_t& sx)
|
||||
{
|
||||
const auto& ni = ii.template get<N>();
|
||||
const size_t max = ni.max();
|
||||
const size_t tmp = getStepSize(ni, j);
|
||||
ss += tmp * ii.template getBlockSize<N+1>();
|
||||
sx *= max;
|
||||
if constexpr(N != 0){
|
||||
getStepSizeX<N-1>(ii, j, ss, sx);
|
||||
}
|
||||
}
|
||||
|
||||
template <class Index>
|
||||
inline size_t getStepSize(const Index& ii, std::intptr_t j)
|
||||
{
|
||||
constexpr IndexType IT = Index::sType();
|
||||
if constexpr(IT == IndexType::SINGLE){
|
||||
const std::intptr_t ip = reinterpret_cast<std::intptr_t>(&ii);
|
||||
return ip == j ? 1 : 0;
|
||||
}
|
||||
else {
|
||||
size_t ss = 0;
|
||||
size_t sx = 1;
|
||||
constexpr size_t DIM = Index::sDim();
|
||||
getStepSizeX<DIM-1>(ii, j, ss, sx);
|
||||
return ss;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <size_t N, size_t SIZE, class Range, class... Ranges>
|
||||
inline bool compareSpaceTypes(const vector<std::shared_ptr<RangeBase> >& rbvec)
|
||||
{
|
||||
if constexpr(N != 0){
|
||||
return rbvec[SIZE-N-1]->spaceType() == Range::STYPE and compareSpaceTypes<N-1,SIZE,Ranges...>(rbvec);
|
||||
}
|
||||
else {
|
||||
return rbvec[SIZE-N-1]->spaceType() == Range::STYPE;
|
||||
}
|
||||
}
|
||||
|
||||
template <size_t N, class... Ranges>
|
||||
inline void setSpace(const vector<std::shared_ptr<RangeBase> >& rbvec,
|
||||
std::tuple<std::shared_ptr<Ranges>...>& stp)
|
||||
{
|
||||
typedef typename std::remove_reference<decltype(*std::get<N>( stp ))>::type RType;
|
||||
std::get<N>( stp ) = std::dynamic_pointer_cast<RType>( rbvec[N] );
|
||||
if constexpr(N != 0){
|
||||
setSpace<N-1>(rbvec, stp);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace RangeHelper
|
||||
} // namespace CNORXZ
|
||||
|
||||
#endif
|
||||
|
|
@ -22,9 +22,9 @@ namespace CNORXZ
|
|||
{}
|
||||
|
||||
template <typename MetaType>
|
||||
UIndex<MetaType>& UIndex<MetaType>::operator=(size_t pos)
|
||||
UIndex<MetaType>& UIndex<MetaType>::operator=(size_t lexpos)
|
||||
{
|
||||
IB::mPos = pos;
|
||||
IB::mPos = lexpos;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -69,7 +69,19 @@ namespace CNORXZ
|
|||
}
|
||||
|
||||
template <typename MetaType>
|
||||
SizeT UIndex<MetaType>::max() const
|
||||
SizeT UIndex<MetaType>::lex() const
|
||||
{
|
||||
return IB::mPos;
|
||||
}
|
||||
|
||||
template <typename MetaType>
|
||||
SizeT UIndex<MetaType>::pmax() const
|
||||
{
|
||||
return mRangePtr->size();
|
||||
}
|
||||
|
||||
template <typename MetaType>
|
||||
SizeT UIndex<MetaType>::lmax() const
|
||||
{
|
||||
return mRangePtr->size();
|
||||
}
|
||||
|
|
@ -128,7 +140,7 @@ namespace CNORXZ
|
|||
template <class Xpr, class F>
|
||||
decltype(auto) UIndex<MetaType>::ifor(const Xpr& xpr, F&& f) const
|
||||
{
|
||||
return For<0,Xpr,F>(this->max(), this->id(), xpr, std::forward<F>(f));
|
||||
return For<0,Xpr,F>(this->pmax(), this->id(), xpr, std::forward<F>(f));
|
||||
}
|
||||
|
||||
/**********************
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ namespace CNORXZ
|
|||
|
||||
UIndex(const RangePtr& range, SizeT pos = 0);
|
||||
|
||||
UIndex& operator=(SizeT pos);
|
||||
UIndex& operator=(SizeT lexpos);
|
||||
UIndex& operator++();
|
||||
UIndex& operator--();
|
||||
UIndex operator+(Int n) const;
|
||||
|
|
@ -30,7 +30,9 @@ namespace CNORXZ
|
|||
UIndex& operator+=(Int n);
|
||||
UIndex& operator-=(Int n);
|
||||
|
||||
SizeT max() const;
|
||||
SizeT lex() const;
|
||||
SizeT pmax() const;
|
||||
SizeT lmax() const;
|
||||
IndexId<0> id() const;
|
||||
|
||||
const MetaT& operator*() const;
|
||||
|
|
|
|||
|
|
@ -32,9 +32,10 @@ namespace CNORXZ
|
|||
}
|
||||
|
||||
template <class Index, typename Meta>
|
||||
XIndex<Index,Meta>& XIndex<Index,Meta>::operator=(SizeT pos)
|
||||
XIndex<Index,Meta>& XIndex<Index,Meta>::operator=(SizeT lexpos)
|
||||
{
|
||||
*mI = pos;
|
||||
mI->THIS() = lexpos;
|
||||
assert(mI->lex() == lexpos);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -79,9 +80,21 @@ namespace CNORXZ
|
|||
}
|
||||
|
||||
template <class Index, typename Meta>
|
||||
SizeT XIndex<Index,Meta>::max() const
|
||||
SizeT XIndex<Index,Meta>::lex() const
|
||||
{
|
||||
return mI->max();
|
||||
return mI->lex();
|
||||
}
|
||||
|
||||
template <class Index, typename Meta>
|
||||
SizeT XIndex<Index,Meta>::pmax() const
|
||||
{
|
||||
return mI->pmax();
|
||||
}
|
||||
|
||||
template <class Index, typename Meta>
|
||||
SizeT XIndex<Index,Meta>::lmax() const
|
||||
{
|
||||
return mI->lmax();
|
||||
}
|
||||
|
||||
template <class Index, typename Meta>
|
||||
|
|
@ -136,9 +149,9 @@ namespace CNORXZ
|
|||
|
||||
template <class Index, typename Meta>
|
||||
DXpr<SizeT> XIndex<Index,Meta>::ifor(const DXpr<SizeT>& xpr,
|
||||
std::function<SizeT(SizeT,SizeT)>&& f) const
|
||||
const std::function<SizeT(SizeT,SizeT)>& f) const
|
||||
{
|
||||
return DXpr<SizeT>(mI->ifor(xpr, std::forward<std::function<SizeT(SizeT,SizeT)>>(f)));
|
||||
return DXpr<SizeT>(mI->ifor(xpr, f));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ namespace CNORXZ
|
|||
virtual XIndexPtr copy() const = 0;
|
||||
virtual SizeT pos() const = 0;
|
||||
|
||||
virtual XIndexBase& operator=(SizeT pos) = 0;
|
||||
virtual XIndexBase& operator=(SizeT lexpos) = 0;
|
||||
virtual XIndexBase& operator++() = 0;
|
||||
virtual XIndexBase& operator--() = 0;
|
||||
virtual XIndexPtr operator+(Int n) const = 0;
|
||||
|
|
@ -25,7 +25,9 @@ namespace CNORXZ
|
|||
virtual XIndexBase& operator+=(Int n) = 0;
|
||||
virtual XIndexBase& operator-=(Int n) = 0;
|
||||
|
||||
virtual SizeT max() const = 0;
|
||||
virtual SizeT lex() const = 0;
|
||||
virtual SizeT pmax() const = 0;
|
||||
virtual SizeT lmax() const = 0;
|
||||
virtual IndexId<0> id() const = 0;
|
||||
|
||||
virtual DType operator*() const = 0;
|
||||
|
|
@ -39,7 +41,7 @@ namespace CNORXZ
|
|||
virtual XIndexBase& at(const DType& meta) = 0;
|
||||
|
||||
virtual DXpr<SizeT> ifor(const DXpr<SizeT>& xpr,
|
||||
std::function<SizeT(SizeT,SizeT)>&& f) const = 0;
|
||||
const std::function<SizeT(SizeT,SizeT)>& f) const = 0;
|
||||
};
|
||||
|
||||
//Sptr<XIndexBase>& operator++(Sptr<XIndexBase>& i);
|
||||
|
|
@ -63,7 +65,7 @@ namespace CNORXZ
|
|||
virtual XIndexPtr copy() const override final;
|
||||
virtual SizeT pos() const override final;
|
||||
|
||||
virtual XIndex& operator=(SizeT pos) override final;
|
||||
virtual XIndex& operator=(SizeT lexpos) override final;
|
||||
virtual XIndex& operator++() override final;
|
||||
virtual XIndex& operator--() override final;
|
||||
virtual XIndexPtr operator+(Int n) const override final;
|
||||
|
|
@ -71,7 +73,9 @@ namespace CNORXZ
|
|||
virtual XIndex& operator+=(Int n) override final;
|
||||
virtual XIndex& operator-=(Int n) override final;
|
||||
|
||||
virtual SizeT max() const override final;
|
||||
virtual SizeT lex() const override final;
|
||||
virtual SizeT pmax() const override final;
|
||||
virtual SizeT lmax() const override final;
|
||||
virtual IndexId<0> id() const override final;
|
||||
|
||||
virtual DType operator*() const override final;
|
||||
|
|
@ -85,7 +89,7 @@ namespace CNORXZ
|
|||
virtual XIndexBase& at(const DType& meta) override final;
|
||||
|
||||
virtual DXpr<SizeT> ifor(const DXpr<SizeT>& xpr,
|
||||
std::function<SizeT(SizeT,SizeT)>&& f) const override final;
|
||||
const std::function<SizeT(SizeT,SizeT)>& f) const override final;
|
||||
|
||||
private:
|
||||
IndexPtr<Index,Meta> mI;
|
||||
|
|
|
|||
|
|
@ -10,10 +10,6 @@
|
|||
|
||||
namespace CNORXZ
|
||||
{
|
||||
// YRange!!!!
|
||||
|
||||
// Future DynamicIndex
|
||||
//class YIndex : public XIndexBase
|
||||
class YIndex : public IndexInterface<YIndex,DType>
|
||||
{
|
||||
public:
|
||||
|
|
@ -21,21 +17,26 @@ namespace CNORXZ
|
|||
typedef YRange RangeType;
|
||||
typedef DType MetaType;
|
||||
|
||||
DEFAULT_MEMBERS(YIndex);
|
||||
YIndex(const RangePtr& range, SizeT pos = 0);
|
||||
YIndex(const RangePtr& range, const Vector<XIndexPtr>& is, SizeT pos = 0);
|
||||
YIndex() = default;
|
||||
YIndex(YIndex&& i) = default;
|
||||
YIndex& operator=(YIndex&& i) = default;
|
||||
|
||||
YIndex& sync(); // remove!!!
|
||||
YIndex(const YIndex& i);
|
||||
YIndex& operator=(const YIndex& i);
|
||||
|
||||
YIndex& operator=(SizeT pos);
|
||||
YIndex(const RangePtr& range, SizeT lexpos);
|
||||
|
||||
YIndex& operator=(SizeT lexpos);
|
||||
YIndex& operator++();
|
||||
YIndex& operator--();
|
||||
YIndex operator+(Int n) const;
|
||||
YIndex operator+(Int n) const; // equivalent to applying n times ++
|
||||
YIndex operator-(Int n) const;
|
||||
YIndex& operator+=(Int n);
|
||||
YIndex& operator-=(Int n);
|
||||
|
||||
SizeT max() const;
|
||||
SizeT lex() const;
|
||||
SizeT pmax() const;
|
||||
SizeT lmax() const;
|
||||
IndexId<0> id() const;
|
||||
|
||||
DType operator*() const;
|
||||
|
|
@ -48,14 +49,28 @@ namespace CNORXZ
|
|||
DType meta() const;
|
||||
YIndex& at(const DType& meta);
|
||||
|
||||
DXpr<SizeT> ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const;
|
||||
DXpr<SizeT> ifor(const DXpr<SizeT>& xpr, const std::function<SizeT(SizeT,SizeT)>& f) const;
|
||||
|
||||
private:
|
||||
inline Vector<SizeT> mkBlockSizes() const;
|
||||
inline Vector<SizeT> mkLexBlockSizes() const;
|
||||
inline Vector<XIndexPtr> mkIndices() const;
|
||||
inline void up(SizeT i);
|
||||
inline void down(SizeT i);
|
||||
inline decltype(auto) mkIFor(SizeT i, const DXpr<SizeT>& xpr,
|
||||
const std::function<SizeT(SizeT,SizeT)>& f) const;
|
||||
|
||||
Sptr<YRange> mRangePtr;
|
||||
inline SizeT mkPMax() const;
|
||||
inline SizeT mkLMax() const;
|
||||
|
||||
SizeT mLPos = 0;
|
||||
Sptr<YRange> mRange;
|
||||
Vector<XIndexPtr> mIs;
|
||||
Vector<SizeT> mBlockSizes; // dim() elements only!!!
|
||||
|
||||
Vector<SizeT> mLexBlockSizes; // dim() elements only!!!
|
||||
SizeT mLex = 0;
|
||||
SizeT mPMax = 0;
|
||||
SizeT mLMax = 0;
|
||||
};
|
||||
|
||||
class YRangeFactory : public RangeFactoryBase
|
||||
|
|
@ -82,6 +97,7 @@ namespace CNORXZ
|
|||
|
||||
friend YRangeFactory;
|
||||
|
||||
virtual RangePtr sub(SizeT i) const override final;
|
||||
virtual SizeT size() const override final;
|
||||
virtual SizeT dim() const override final;
|
||||
virtual String stringMeta(SizeT pos) const override final;
|
||||
|
|
|
|||
|
|
@ -11,9 +11,9 @@ namespace CNORXZ
|
|||
IndexInterface<CIndex,SizeT>(pos), mRangePtr(rangeCast<RangeType>(range))
|
||||
{}
|
||||
|
||||
CIndex& CIndex::operator=(SizeT pos)
|
||||
CIndex& CIndex::operator=(SizeT lexpos)
|
||||
{
|
||||
IB::mPos = pos;
|
||||
IB::mPos = lexpos;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -51,11 +51,21 @@ namespace CNORXZ
|
|||
return *this;
|
||||
}
|
||||
|
||||
SizeT CIndex::max() const
|
||||
SizeT CIndex::lex() const
|
||||
{
|
||||
return IB::mPos;
|
||||
}
|
||||
|
||||
SizeT CIndex::lmax() const
|
||||
{
|
||||
return mRangePtr->size();
|
||||
}
|
||||
|
||||
|
||||
SizeT CIndex::pmax() const
|
||||
{
|
||||
return mRangePtr->size();
|
||||
}
|
||||
|
||||
IndexId<0> CIndex::id() const
|
||||
{
|
||||
return IndexId<0>(this->ptrId());
|
||||
|
|
|
|||
|
|
@ -37,9 +37,9 @@ namespace CNORXZ
|
|||
mI(i)
|
||||
{}
|
||||
|
||||
DIndex& DIndex::operator=(SizeT pos)
|
||||
DIndex& DIndex::operator=(SizeT lexpos)
|
||||
{
|
||||
*mI = pos;
|
||||
*mI = lexpos;
|
||||
IB::mPos = mI->pos();
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -82,6 +82,26 @@ namespace CNORXZ
|
|||
return *this;
|
||||
}
|
||||
|
||||
SizeT DIndex::lex() const
|
||||
{
|
||||
return mI->lex();
|
||||
}
|
||||
|
||||
SizeT DIndex::pmax() const
|
||||
{
|
||||
return mI->pmax();
|
||||
}
|
||||
|
||||
SizeT DIndex::lmax() const
|
||||
{
|
||||
return mI->lmax();
|
||||
}
|
||||
|
||||
IndexId<0> DIndex::id() const
|
||||
{
|
||||
return mI->id();
|
||||
}
|
||||
|
||||
DType DIndex::operator*() const
|
||||
{
|
||||
return *(*mI);
|
||||
|
|
@ -124,4 +144,8 @@ namespace CNORXZ
|
|||
return DXpr<SizeT>(mI->ifor(xpr, std::forward<std::function<SizeT(SizeT,SizeT)>>(f)) );
|
||||
}
|
||||
|
||||
const XIndexPtr& DIndex::xptr() const
|
||||
{
|
||||
return mI;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ namespace CNORXZ
|
|||
|
||||
RangePtr operator*(const RangePtr& a, const RangePtr& b)
|
||||
{
|
||||
assert(0); // check segfault + "flatten" yrange (no yrange of yranges etc)
|
||||
//assert(0); // check segfault + "flatten" yrange (no yrange of yranges etc)
|
||||
return YRangeFactory({a,b}).create();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,96 +3,216 @@
|
|||
|
||||
namespace CNORXZ
|
||||
{
|
||||
/*************************
|
||||
* YIndex (private) *
|
||||
*************************/
|
||||
|
||||
inline Vector<XIndexPtr> YIndex::mkIndices() const
|
||||
{
|
||||
Vector<XIndexPtr> o(mRange->dim(), nullptr);
|
||||
for(SizeT i = 0; i != mRange->dim(); ++i){
|
||||
auto rp = mRange->sub(i);
|
||||
CXZ_ASSERT(rp != nullptr, "subranges not available");
|
||||
o[i] = rp->begin().xptr();
|
||||
}
|
||||
return o;
|
||||
}
|
||||
|
||||
inline Vector<SizeT> YIndex::mkBlockSizes() const
|
||||
{
|
||||
Vector<SizeT> o(mIs.size());
|
||||
SizeT b = 1;
|
||||
for(SizeT i = o.size(); i != 0; --i){
|
||||
const SizeT j = i-1;
|
||||
o[j] = b;
|
||||
b *= mIs[j]->pmax();
|
||||
}
|
||||
return o;
|
||||
}
|
||||
|
||||
inline Vector<SizeT> YIndex::mkLexBlockSizes() const
|
||||
{
|
||||
Vector<SizeT> o(mIs.size());
|
||||
SizeT b = 1;
|
||||
for(SizeT i = o.size(); i != 0; --i){
|
||||
const SizeT j = i-1;
|
||||
o[j] = b;
|
||||
b *= mIs[j]->lmax();
|
||||
}
|
||||
return o;
|
||||
}
|
||||
|
||||
inline void YIndex::up(SizeT i)
|
||||
{
|
||||
auto& idx = mIs[i];
|
||||
// it is guaranteed that the last accessible position
|
||||
// is one less than the max position (=end)
|
||||
if(i != 0 and idx->lex() == idx->lmax()-1){
|
||||
IB::mPos -= mBlockSizes[i] * idx->pos();
|
||||
(*idx) = 0;
|
||||
up(i-1);
|
||||
return;
|
||||
}
|
||||
IB::mPos += mBlockSizes[i];
|
||||
++(*idx);
|
||||
}
|
||||
|
||||
inline void YIndex::down(SizeT i)
|
||||
{
|
||||
auto& idx = mIs[i];
|
||||
if(i != 0 and idx->pos() == 0){
|
||||
(*idx) = idx->lmax()-1;
|
||||
IB::mPos += mBlockSizes[i] * idx->pos();
|
||||
down(i-1);
|
||||
return;
|
||||
}
|
||||
IB::mPos += mBlockSizes[i];
|
||||
--(*idx);
|
||||
}
|
||||
|
||||
inline decltype(auto) YIndex::mkIFor(SizeT i, const DXpr<SizeT>& xpr,
|
||||
const std::function<SizeT(SizeT,SizeT)>& f) const
|
||||
{
|
||||
if(i == mIs.size()-1){
|
||||
return mIs[i]->ifor( xpr, f );
|
||||
}
|
||||
else {
|
||||
return mIs[i]->ifor( mkIFor(i+1, xpr, f), f );
|
||||
}
|
||||
}
|
||||
|
||||
inline SizeT YIndex::mkPMax() const
|
||||
{
|
||||
SizeT o = 0;
|
||||
for(SizeT i = 0; i != mIs.size(); ++i){
|
||||
o += (mIs[i]->pmax()-1) * mBlockSizes[i];
|
||||
}
|
||||
return o+1;
|
||||
}
|
||||
|
||||
inline SizeT YIndex::mkLMax() const
|
||||
{
|
||||
return std::accumulate(mIs.begin(), mIs.end(),1,
|
||||
[](const auto& res, const auto& el) { return res * el->lmax(); } );
|
||||
}
|
||||
|
||||
|
||||
/***************
|
||||
* YIndex *
|
||||
***************/
|
||||
|
||||
YIndex::YIndex(const RangePtr& range, SizeT pos) :
|
||||
IndexInterface<YIndex,DType>(pos),
|
||||
mRangePtr(rangeCast<YRange>(range)), mIs(mRangePtr->dim()),
|
||||
mBlockSizes(mRangePtr->dim())
|
||||
YIndex::YIndex(const YIndex& i) :
|
||||
IndexInterface<YIndex,DType>(i),
|
||||
mRange(rangeCast<YRange>(i.range())),
|
||||
mIs(mkIndices()),
|
||||
mBlockSizes(mkBlockSizes()),
|
||||
mLexBlockSizes(mkLexBlockSizes()),
|
||||
mPMax(mkPMax()),
|
||||
mLMax(mkLMax())
|
||||
{
|
||||
assert(0);
|
||||
// init ...!!!
|
||||
}
|
||||
|
||||
YIndex::YIndex(const RangePtr& range, const Vector<XIndexPtr>& is, SizeT pos) :
|
||||
IndexInterface<YIndex,DType>(pos),
|
||||
mRangePtr(rangeCast<YRange>(range)), mIs(is),
|
||||
mBlockSizes(mRangePtr->dim())
|
||||
{
|
||||
CXZ_ASSERT(mIs.size() == mRangePtr->dim(), "obtained wrong number of indices");
|
||||
assert(0);
|
||||
// init ...!!!
|
||||
}
|
||||
|
||||
YIndex& YIndex::sync()
|
||||
{
|
||||
assert(0);
|
||||
return *this;
|
||||
*this = i.lex();
|
||||
}
|
||||
|
||||
YIndex& YIndex::operator=(SizeT pos)
|
||||
YIndex& YIndex::operator=(const YIndex& i)
|
||||
{
|
||||
IB::mPos = pos;
|
||||
assert(0);
|
||||
// sub inds... (LAZY!!!) !!!
|
||||
IndexInterface<YIndex,DType>::operator=(i);
|
||||
mRange = rangeCast<YRange>(i.range());
|
||||
mIs = mkIndices();
|
||||
mBlockSizes = mkBlockSizes();
|
||||
mLexBlockSizes = mkLexBlockSizes();
|
||||
mPMax = mkPMax();
|
||||
mLMax = mkLMax();
|
||||
return *this = i.lex();
|
||||
}
|
||||
|
||||
YIndex::YIndex(const RangePtr& range, SizeT lexpos) :
|
||||
IndexInterface<YIndex,DType>(0),
|
||||
mRange(rangeCast<YRange>(range)),
|
||||
mIs(mkIndices()),
|
||||
mBlockSizes(mkBlockSizes()),
|
||||
mLexBlockSizes(mkLexBlockSizes()),
|
||||
mPMax(mkPMax()),
|
||||
mLMax(mkLMax())
|
||||
{
|
||||
*this = lexpos;
|
||||
}
|
||||
|
||||
YIndex& YIndex::operator=(SizeT lexpos)
|
||||
{
|
||||
mLex = lexpos;
|
||||
if(lexpos == lmax()){
|
||||
IB::mPos = pmax();
|
||||
return *this;
|
||||
}
|
||||
IB::mPos = 0;
|
||||
for(SizeT i = 0; i != mIs.size(); ++i){
|
||||
*mIs[i] = (lex() / mLexBlockSizes[i]) % mIs[i]->lmax();
|
||||
IB::mPos += mBlockSizes[i] * mIs[i]->pos();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
YIndex& YIndex::operator++()
|
||||
{
|
||||
assert(0);
|
||||
// increment sub inds (LAZY!!!) !!!
|
||||
++mPos;
|
||||
auto& i0 = mIs[0];
|
||||
if(i0->lex() != i0->lmax()){
|
||||
up(mIs.size()-1);
|
||||
}
|
||||
// no else! up() changes i0!
|
||||
if(i0->lex() == i0->lmax()){
|
||||
IB::mPos = pmax();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
YIndex& YIndex::operator--()
|
||||
{
|
||||
assert(0);
|
||||
// decrement sub inds (LAZY!!!) !!!
|
||||
--mPos;
|
||||
auto& i0 = mIs[0];
|
||||
if(i0->lex() == i0->lmax()){
|
||||
IB::mPos = mBlockSizes[0] * i0->pmax();
|
||||
}
|
||||
if(lex() != 0){
|
||||
down(mIs.size()-1);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
YIndex YIndex::operator+(Int n) const
|
||||
{
|
||||
assert(0);
|
||||
// sub inds !!!
|
||||
return YIndex(mRangePtr, IB::mPos + n);
|
||||
YIndex o(*this);
|
||||
return o += n;
|
||||
}
|
||||
|
||||
YIndex YIndex::operator-(Int n) const
|
||||
{
|
||||
assert(0);
|
||||
// sub inds !!!
|
||||
return YIndex(mRangePtr, IB::mPos - n);
|
||||
YIndex o(*this);
|
||||
return o -= n;
|
||||
}
|
||||
|
||||
YIndex& YIndex::operator+=(Int n)
|
||||
{
|
||||
assert(0);
|
||||
// sub inds !!!
|
||||
IB::mPos += n;
|
||||
return *this;
|
||||
return *this = lex() + n;
|
||||
}
|
||||
|
||||
YIndex& YIndex::operator-=(Int n)
|
||||
{
|
||||
assert(0);
|
||||
// sub inds !!!
|
||||
IB::mPos -= n;
|
||||
return *this;
|
||||
|
||||
return *this = lex() - n;
|
||||
}
|
||||
|
||||
SizeT YIndex::max() const
|
||||
SizeT YIndex::lex() const
|
||||
{
|
||||
SizeT o = 1;
|
||||
for(auto& i: mIs){
|
||||
o *= i->max();
|
||||
}
|
||||
return o;
|
||||
return mLex;
|
||||
}
|
||||
|
||||
SizeT YIndex::pmax() const
|
||||
{
|
||||
return mPMax;
|
||||
}
|
||||
|
||||
SizeT YIndex::lmax() const
|
||||
{
|
||||
return mLMax;
|
||||
}
|
||||
|
||||
IndexId<0> YIndex::id() const
|
||||
|
|
@ -102,42 +222,45 @@ namespace CNORXZ
|
|||
|
||||
DType YIndex::operator*() const
|
||||
{
|
||||
assert(0);
|
||||
return DType();
|
||||
return meta();
|
||||
}
|
||||
|
||||
SizeT YIndex::dim() const
|
||||
{
|
||||
return mRangePtr->dim();
|
||||
return mRange->dim();
|
||||
}
|
||||
|
||||
Sptr<YRange> YIndex::range() const
|
||||
{
|
||||
return mRangePtr;
|
||||
return mRange;
|
||||
}
|
||||
|
||||
UPos YIndex::stepSize(const IndexId<0> id) const
|
||||
{
|
||||
assert(0);
|
||||
// sub inds !!!
|
||||
return UPos(0);
|
||||
SizeT o = 0;
|
||||
for(SizeT i = 0; i != mIs.size(); ++i){
|
||||
const auto u = mIs[i]->stepSize(id) * UPos(mBlockSizes[i]);
|
||||
o += u.val();
|
||||
}
|
||||
return UPos(o);
|
||||
}
|
||||
|
||||
String YIndex::stringMeta() const
|
||||
{
|
||||
String out = "[";
|
||||
auto it = mIs.begin();
|
||||
for(; it != mIs.end()-1; ++it){
|
||||
out += (*it)->stringMeta() + ",";
|
||||
}
|
||||
out += (*it)->stringMeta() + "]";
|
||||
return out;
|
||||
const String blim = "[";
|
||||
const String elim = "]";
|
||||
const String dlim = ",";
|
||||
return blim +
|
||||
std::accumulate(std::next(mIs.begin()), mIs.end(), mIs[0]->stringMeta(),
|
||||
[&](const auto& s, const auto& e)
|
||||
{ return s + dlim + e->stringMeta(); } ) +
|
||||
elim;
|
||||
}
|
||||
|
||||
DType YIndex::meta() const
|
||||
{
|
||||
Vector<DType> v(mIs.size());
|
||||
std::transform(mIs.begin(), mIs.end(), v.begin(), [](auto& x) { return x->meta(); });
|
||||
std::transform(mIs.begin(), mIs.end(), v.begin(), [](const auto& x) { return x->meta(); });
|
||||
return DType(v);
|
||||
}
|
||||
|
||||
|
|
@ -145,17 +268,17 @@ namespace CNORXZ
|
|||
{
|
||||
auto& v = std::any_cast<const Vector<DType>&>(meta.get());
|
||||
assert(v.size() == mIs.size());
|
||||
IB::mPos = 0;
|
||||
for(SizeT i = 0; i != mIs.size(); ++i){
|
||||
mIs[i]->at(v[i]);
|
||||
IB::mPos += mIs[i]->pos() * mBlockSizes[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
DXpr<SizeT> YIndex::ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const
|
||||
DXpr<SizeT> YIndex::ifor(const DXpr<SizeT>& xpr, const std::function<SizeT(SizeT,SizeT)>& f) const
|
||||
{
|
||||
assert(0);
|
||||
f(0,0);
|
||||
return DXpr<SizeT>();
|
||||
return mkIFor(0, xpr, f);
|
||||
}
|
||||
|
||||
/**********************
|
||||
|
|
@ -176,7 +299,7 @@ namespace CNORXZ
|
|||
|
||||
void YRangeFactory::make()
|
||||
{
|
||||
Vector<PtrId> key;
|
||||
Vector<PtrId> key(mRVec.size());
|
||||
std::transform(mRVec.begin(), mRVec.end(), key.begin(),
|
||||
[&](const RangePtr& r) { return r->id(); } );
|
||||
mProd = this->fromCreated(typeid(YRange), key);
|
||||
|
|
@ -191,6 +314,11 @@ namespace CNORXZ
|
|||
* YRange *
|
||||
***************/
|
||||
|
||||
RangePtr YRange::sub(SizeT i) const
|
||||
{
|
||||
return mRVec[i];
|
||||
}
|
||||
|
||||
SizeT YRange::size() const
|
||||
{
|
||||
SizeT out = 1;
|
||||
|
|
|
|||
|
|
@ -51,6 +51,21 @@ namespace
|
|||
Vector<String> mMeta;
|
||||
SizeT mSize;
|
||||
};
|
||||
|
||||
class YR_Test : public ::testing::Test
|
||||
{
|
||||
protected:
|
||||
|
||||
YR_Test()
|
||||
{
|
||||
mMeta = { "test", "strings", "foo" };
|
||||
std::sort(mMeta.begin(), mMeta.end(), std::less<String>());
|
||||
mSize = 7;
|
||||
}
|
||||
|
||||
Vector<String> mMeta;
|
||||
SizeT mSize;
|
||||
};
|
||||
|
||||
TEST_F(CR_Test, Basics)
|
||||
{
|
||||
|
|
@ -175,7 +190,22 @@ namespace
|
|||
++cnt;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_F(YR_Test, Basics)
|
||||
{
|
||||
auto cr = CRangeFactory(mSize).create();
|
||||
auto ur = URangeFactory<String>(mMeta).create();
|
||||
auto yr = cr * ur;
|
||||
|
||||
EXPECT_EQ(yr->size(), mMeta.size()*mSize);
|
||||
EXPECT_EQ(yr->dim(), 2u);
|
||||
|
||||
EXPECT_TRUE(yr->begin() != yr->end());
|
||||
EXPECT_FALSE(yr->begin() == yr->end());
|
||||
EXPECT_EQ(yr->begin().pos(), 0u);
|
||||
EXPECT_EQ(yr->end().pos(), yr->size());
|
||||
|
||||
}
|
||||
// RCast_Test
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue