chizeta/cnorxz
chizeta/cnorxz
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

indices: fullfill missing iterator requirements

Browse source
This commit is contained in:
Christian Zimmermann 2023-06-11 22:28:10 +02:00
parent 811e955491
commit 1919d373df
15 changed files with 140 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/include/base/macros.h
View file

@ -32,6 +32,12 @@
#define SP_DEFAULT_MEMBERS_X(__spec__,__class_name__) SP_DEFAULT_COPY(__spec__,__class_name__); SP_DEFAULT_MOVE(__spec__,__class_name__)
#define SP_DEFAULT_MEMBERS(__spec__,__class_name__) SP_DEFAULT_C(__spec__,__class_name__); SP_DEFAULT_MEMBERS_X(__spec__,__class_name__)
#define INDEX_RANDOM_ACCESS_ITERATOR_DEFS(__meta_type__) typedef std::random_access_iterator_tag iterator_category; \
typedef SizeT difference_type; \
typedef __meta_type__ value_type; \
typedef const __meta_type__* pointer; \
typedef const __meta_type__& reference
#define CXZ_CVAL_FALSE static constexpr bool value = false
#define CXZ_CVAL_TRUE static constexpr bool value = true

2
src/include/ranges/crange.h
View file

@ -17,6 +17,8 @@ namespace CNORXZ
typedef CRange RangeType;
typedef SizeT MetaType;
INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
DEFAULT_MEMBERS(CIndex);
CIndex(const RangePtr& range, SizeT pos = 0);
CIndex& operator=(SizeT lexpos);

19
src/include/ranges/eindex.cc.h
View file

@ -22,7 +22,7 @@ namespace CNORXZ
return EFor<S,L,Xpr>(mLI->id(), xpr, std::forward<F>(f));
}
template <typename MetaType, SizeT S, SizeT L, class I1>
template <typename MetaT, SizeT S, SizeT L, class I1>
decltype(auto) operator*(const Sptr<EIndex<MetaT,S,L>>& a, const Sptr<I1>& b)
{
return iptrMul(a, b);
@ -31,16 +31,16 @@ namespace CNORXZ
template <typename MetaT, SizeT S, SizeT L>
decltype(auto) eindexPtr(const Sptr<LIndex<SIndex<MetaT,S>,L>>& i)
{
return std::make_shared<EIndex<MetaT,S>>(i);
return std::make_shared<EIndex<MetaT,S,L>>(i);
}
template <SizeT L, typename MetaType, SizeT S>
template <SizeT L, typename MetaT, SizeT S>
decltype(auto) eindexPtr(const Sptr<SIndex<MetaT,S>>& i)
{
return eindexPtr( lindexPtr<L>( i ) );
}
template <typename MetaType, SizeT S, SizeT L>
template <typename MetaT, SizeT S, SizeT L>
decltype(auto) eindexPtr(const Sptr<SIndex<MetaT,S>>& i, CSizeT<L> l)
{
return eindexPtr<l>( i );
@ -49,16 +49,19 @@ namespace CNORXZ
template <SizeT S, SizeT L1, SizeT L2, class Index>
decltype(auto) eplex(const Sptr<Index>& i)
{
const SizeT isize = i->lmax().val()
const SizeT isize = i->lmax().val();
CXZ_ASSERT(isize % S == 0, "index max (= " << isize
<< " ) not dividable by extension size = " << S);
auto ci = std::make_shared<CIndex>( CRangeFactory(isize/L).create() );
auto ei = eindexPtr<L1>( std::make_shared<SIndex<S>>( SRangeFactory<S>().create() ) );
auto ci = std::make_shared<CIndex>( CRangeFactory(isize/S).create() );
auto m = iter<0,S>([](auto i) { return i; },
[](const auto&... e) { return Arr<SizeT,S>{ e... }; } );
auto ei = eindexPtr<L1>( std::make_shared<SIndex<SizeT,S>>
( SRangeFactory<SizeT,S>(m).create() ) );
if constexpr(L2 == 0){
return spackp(ci,ei);
}
else {
return spackp(lindex<L2>(ci),ei);
return spackp(lindexPtr<L2>(ci),ei);
}
}

19
src/include/ranges/eindex.h
View file

@ -18,8 +18,7 @@ namespace CNORXZ
typedef typename LIndex<SIndex<MetaT,S>,L>::RangeType RangeType;
DEFAULT_MEMBERS(EIndex);
EIndex(const LIndex<SIndex<MetaT,S>,L>& i);
EIndex(LIndex<SIndex<MetaT,S>,L>&& i);
EIndex(const Sptr<LIndex<SIndex<MetaT,S>,L>>& i);
template <class Xpr, class F>
decltype(auto) ifor(const Xpr& xpr, F&& f) const;
@ -28,16 +27,22 @@ namespace CNORXZ
Sptr<LIndex<SIndex<MetaT,S>,L>> mLI;
};
template <typename MetaType, SizeT S, SizeT L, class I1>
decltype(auto) operator*(const Sptr<EIndex<MetaType,S>>& a, const Sptr<I1>& b);
template <typename MetaT, SizeT S, SizeT L>
struct is_index<EIndex<MetaT,S,L>>
{
static constexpr bool value = true;
};
template <typename MetaT, SizeT S, SizeT L, class I1>
decltype(auto) operator*(const Sptr<EIndex<MetaT,S,L>>& a, const Sptr<I1>& b);
template <typename MetaType, SizeT S, SizeT L>
template <typename MetaT, SizeT S, SizeT L>
decltype(auto) eindexPtr(const Sptr<LIndex<SIndex<MetaT,S>,L>>& i);
template <SizeT L, typename MetaType, SizeT S>
template <SizeT L, typename MetaT, SizeT S>
decltype(auto) eindexPtr(const Sptr<SIndex<MetaT,S>>& i);
template <typename MetaType, SizeT S, SizeT L>
template <typename MetaT, SizeT S, SizeT L>
decltype(auto) eindexPtr(const Sptr<SIndex<MetaT,S>>& i, CSizeT<L> l);
template <SizeT S, SizeT L1, SizeT L2, class Index>

6
src/include/ranges/index_format.cc.h
View file

@ -68,10 +68,10 @@ namespace CNORXZ
template <class FormatT>
constexpr GMFormat<PosT...>::GMFormat(const FormatT& f)
{
static_assert(f.size() == size(), "try to assign format of wrong dimension");
iter<0,sizeof...(PosT)>( [&](auto i) { mB[i] = f[i]; }, NoF{} );
CXZ_ASSERT(f.size() == size(), "try to assign format of wrong dimension");
iter<0,sizeof...(PosT)>( [&](auto i) { std::get<i>(mB) = f[i].val(); }, NoF{} );
}
template <class... PosT>
const Tuple<PosT...>& GMFormat<PosT...>::all() const
{

2
src/include/ranges/lindex.cc.h
View file

@ -44,7 +44,7 @@ namespace CNORXZ
template <SizeT L, class Index>
decltype(auto) lindexPtr(const Sptr<Index>& i)
{
return LIndex<Index,L>( i );
return std::make_shared<LIndex<Index,L>>( i );
}
template <class Index, SizeT L>

5
src/include/ranges/lindex.h
View file

@ -29,6 +29,11 @@ namespace CNORXZ
Sptr<Index> mI;
};
template <class Index, SizeT L>
struct is_index<LIndex<Index,L>>
{
static constexpr bool value = is_index<Index>::value;
};
template <class Index, SizeT L, class I1>
decltype(auto) operator*(const Sptr<LIndex<Index,L>>& a, const Sptr<I1>& b);

5
src/include/ranges/mrange.h
View file

@ -27,10 +27,11 @@ namespace CNORXZ
typedef MRange<typename Indices::RangeType...> RangeType;
static constexpr SizeT NI = sizeof...(Indices);
INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
constexpr GMIndex() = default;
constexpr GMIndex(GMIndex&& i) = default;
constexpr GMIndex& operator=(GMIndex&& i) = default;
// no defaults:
constexpr GMIndex(const GMIndex& i);
constexpr GMIndex& operator=(const GMIndex& i);
@ -103,7 +104,7 @@ namespace CNORXZ
Sptr<RangeType> mRange;
SPack<Indices...> mIPack;
typedef RemoveRef<decltype(mkLexFormat(mIPack,Isqr<0,NI-1>{}))> LexFormatT;
typedef RemoveRef<decltype(mkLexFormat(mIPack,Isqr<1,NI>{}))> LexFormatT;
LexFormatT mLexFormat;
FormatT mFormat;
SizeT mLex;

2
src/include/ranges/ranges.cc.h
View file

@ -4,10 +4,12 @@
#include "mrange.cc.h"
#include "xindex.cc.h"
#include "urange.cc.h"
#include "srange.cc.h"
#include "crange.cc.h"
#include "prange.cc.h"
#include "dindex.cc.h"
#include "lindex.cc.h"
#include "eindex.cc.h"
#include "index_mul.cc.h"
#include "index_pack.cc.h"
#include "index_format.cc.h"

7
src/include/ranges/ranges.h
View file

@ -2,12 +2,15 @@
#include "range_base.h"
#include "index_base.h"
#include "mrange.h"
#include "crange.h"
#include "prange.h"
#include "xindex.h"
#include "yrange.h"
#include "urange.h"
#include "srange.h"
#include "crange.h"
#include "prange.h"
#include "dindex.h"
#include "lindex.h"
#include "eindex.h"
#include "index_mul.h"
#include "index_pack.h"
#include "index_format.h"

118
src/include/ranges/srange.cc.h
View file

@ -10,8 +10,8 @@ namespace CNORXZ
* SIndex *
**************/
template <typename Meta, SizeT S>
SIndex<Meta,S>::SIndex(const RangePtr& range, SizeT pos) :
template <typename MetaT, SizeT S>
SIndex<MetaT,S>::SIndex(const RangePtr& range, SizeT pos) :
IndexInterface<SIndex<MetaT,S>,MetaT>(pos),
mRangePtr(rangeCast<RangeType>(range)),
mMetaPtr(&mRangePtr->get(0))
@ -20,137 +20,137 @@ namespace CNORXZ
<< ", expected " << S);
}
template <typename Meta, SizeT S>
SIndex& SIndex<Meta,S>::operator=(SizeT lexpos)
template <typename MetaT, SizeT S>
SIndex<MetaT,S>& SIndex<MetaT,S>::operator=(SizeT lexpos)
{
IB::mPos = lexpos;
return *this;
}
template <typename Meta, SizeT S>
SIndex& SIndex<Meta,S>::operator++()
template <typename MetaT, SizeT S>
SIndex<MetaT,S>& SIndex<MetaT,S>::operator++()
{
++IB::mPos;
return *this;
}
template <typename Meta, SizeT S>
SIndex& SIndex<Meta,S>::operator--()
template <typename MetaT, SizeT S>
SIndex<MetaT,S>& SIndex<MetaT,S>::operator--()
{
--IB::mPos;
return *this;
}
template <typename Meta, SizeT S>
SIndex SIndex<Meta,S>::operator+(Int n) const
template <typename MetaT, SizeT S>
SIndex<MetaT,S> SIndex<MetaT,S>::operator+(Int n) const
{
return SIndex(mRangePtr, IB::mPos + n);
}
template <typename Meta, SizeT S>
SIndex SIndex<Meta,S>::operator-(Int n) const
template <typename MetaT, SizeT S>
SIndex<MetaT,S> SIndex<MetaT,S>::operator-(Int n) const
{
return SIndex(mRangePtr, IB::mPos - n);
}
template <typename Meta, SizeT S>
SIndex& SIndex<Meta,S>::operator+=(Int n)
template <typename MetaT, SizeT S>
SIndex<MetaT,S>& SIndex<MetaT,S>::operator+=(Int n)
{
IB::mPos += n;
return *this;
}
template <typename Meta, SizeT S>
SIndex& SIndex<Meta,S>::operator-=(Int n)
template <typename MetaT, SizeT S>
SIndex<MetaT,S>& SIndex<MetaT,S>::operator-=(Int n)
{
IB::mPos -= n;
return *this;
}
template <typename Meta, SizeT S>
SizeT SIndex<Meta,S>::lex() const
template <typename MetaT, SizeT S>
SizeT SIndex<MetaT,S>::lex() const
{
return IB::mPos;
}
template <typename Meta, SizeT S>
SPos<S> SIndex<Meta,S>::pmax() const
template <typename MetaT, SizeT S>
SPos<S> SIndex<MetaT,S>::pmax() const
{
return SPos<S>();
}
template <typename Meta, SizeT S>
SPos<S> SIndex<Meta,S>::lmax() const
template <typename MetaT, SizeT S>
SPos<S> SIndex<MetaT,S>::lmax() const
{
return SPos<S>();
}
template <typename Meta, SizeT S>
IndexId<0> SIndex<Meta,S>::id() const
template <typename MetaT, SizeT S>
IndexId<0> SIndex<MetaT,S>::id() const
{
return IndexId<0>(this->ptrId());
}
template <typename Meta, SizeT S>
const MetaT& SIndex<Meta,S>::operator*() const
template <typename MetaT, SizeT S>
const MetaT& SIndex<MetaT,S>::operator*() const
{
return mMetaPtr[IB::mPos];
}
template <typename Meta, SizeT S>
SizeT SIndex<Meta,S>::dim() const
template <typename MetaT, SizeT S>
SizeT SIndex<MetaT,S>::dim() const
{
return 1;
}
template <typename Meta, SizeT S>
Sptr<RangeType> SIndex<Meta,S>::range() const
template <typename MetaT, SizeT S>
Sptr<SRange<MetaT,S>> SIndex<MetaT,S>::range() const
{
return mRangePtr;
}
template <typename Meta, SizeT S>
template <typename MetaT, SizeT S>
template <SizeT I>
UPos SIndex<Meta,S>::stepSize(const IndexId<I>& id) const
UPos SIndex<MetaT,S>::stepSize(const IndexId<I>& id) const
{
return UPos(id == this->id() ? 1 : 0);
}
template <typename Meta, SizeT S>
String SIndex<Meta,S>::stringMeta() const
template <typename MetaT, SizeT S>
String SIndex<MetaT,S>::stringMeta() const
{
return toString(this->meta());
}
template <typename Meta, SizeT S>
const MetaT& SIndex<Meta,S>::meta() const
template <typename MetaT, SizeT S>
const MetaT& SIndex<MetaT,S>::meta() const
{
return mMetaPtr[IB::mPos];
}
template <typename Meta, SizeT S>
SIndex& SIndex<Meta,S>::at(const MetaT& metaPos)
template <typename MetaT, SizeT S>
SIndex<MetaT,S>& SIndex<MetaT,S>::at(const MetaT& metaPos)
{
(*this) = mRangePtr->getMeta(metaPos);
return *this;
}
template <typename Meta, SizeT S>
decltype(auto) SIndex<Meta,S>::xpr(const Sptr<SIndex<MetaType,S>>& _this) const
template <typename MetaT, SizeT S>
decltype(auto) SIndex<MetaT,S>::xpr(const Sptr<SIndex<MetaType,S>>& _this) const
{
return coproot(mMetaPtr,_this);
}
template <typename Meta, SizeT S>
template <typename MetaT, SizeT S>
template <class Index>
decltype(auto) SIndex<Meta,S>::reformat(const Sptr<Index>& ind) const
decltype(auto) SIndex<MetaT,S>::reformat(const Sptr<Index>& ind) const
{
return ind;
}
template <typename Meta, SizeT S>
template <typename MetaT, SizeT S>
template <class Index>
decltype(auto) SIndex<Meta,S>::slice(const Sptr<Index>& ind) const
decltype(auto) SIndex<MetaT,S>::slice(const Sptr<Index>& ind) const
{
if(ind != nullptr){
if(ind->dim() != 0) {
@ -160,9 +160,9 @@ namespace CNORXZ
return std::make_shared<SIndex<MetaType,S>>(*this);
}
template <typename Meta, SizeT S>
template <typename MetaT, SizeT S>
template <class Xpr, class F>
decltype(auto) SIndex<Meta,S>::ifor(const Xpr& xpr, F&& f) const
decltype(auto) SIndex<MetaT,S>::ifor(const Xpr& xpr, F&& f) const
{
return SFor<S,0,Xpr,F>(this->id(), xpr, std::forward<F>(f));
}
@ -183,7 +183,7 @@ namespace CNORXZ
mSpace(space) {}
template <typename MetaType, SizeT S>
SRangeFactory<MetaType,S>::SRangeFactory(Arr<MetaType,S>&& space)
SRangeFactory<MetaType,S>::SRangeFactory(Arr<MetaType,S>&& space) :
mSpace(std::forward<Arr<MetaType,S>>(space)) {}
template <typename MetaType, SizeT S>
@ -233,57 +233,67 @@ namespace CNORXZ
CXZ_ASSERT(itdupl == mSpace.end(), "found duplicate: " << *itdupl);
}
template <typename MetaType, SizeT S>
SizeT SRange<MetaType,S>::size() const
{
return S;
}
template <typename MetaType, SizeT S>
SizeT SRange<MetaType,S>::dim() const
{
return 1;
}
template <typename MetaType, SizeT S>
String SRange<MetaType,S>::stringMeta(SizeT pos) const
{
return toString(mSpace[pos]);
}
template <typename MetaType, SizeT S>
const TypeInfo& SRange<MetaType,S>::type() const
{
return typeid(SRange<MetaType,S>);
}
template <typename MetaType, SizeT S>
const TypeInfo& SRange<MetaType,S>::metaType() const
{
return typeid(MetaType);
}
template <typename MetaType, SizeT S>
RangePtr SRange<MetaType,S>::extend(const RangePtr& r) const
{
// TODO: check for selected static sizes of SRange -> return SRange!!!
auto rx = rangeCast<URange<MetaType>>(r);
Vector<MetaType> space(mSpace.begin(), mSpace.end());
space.insert(space.end(), rx->mSpace.begin(), rx->mSpace.end());
space.insert(space.end(), rx->begin(), rx->end());
return URangeFactory<MetaType>( space ).create();
}
const MetaType& SRange<MetaType,S>::get(SizeT pos) const;
template <typename MetaType, SizeT S>
const MetaType& SRange<MetaType,S>::get(SizeT pos) const
{
return mSpace[pos];
}
const MetaType* SRange<MetaType,S>::get() const;
template <typename MetaType, SizeT S>
const MetaType* SRange<MetaType,S>::get() const
{
return mSpace.data();
}
SizeT SRange<MetaType,S>::getMeta(const MetaType& metaPos) const;
template <typename MetaType, SizeT S>
SizeT SRange<MetaType,S>::getMeta(const MetaType& metaPos) const
{
auto b = mSpace.begin();
auto e = mSpace.end();
return std::lower_bound(b, e, meta, std::less<MetaType>()) - b;
return std::lower_bound(b, e, metaPos, std::less<MetaType>()) - b;
}
template <typename MetaType, SizeT S>
Vector<Uuid> SRange<MetaType,S>::key() const
{
return Vector<Uuid> { this->id() };
@ -298,10 +308,10 @@ namespace CNORXZ
{
Sptr<URange<MetaType>> tmp;
if(r->type() != typeid(URange<MetaType>)){
tmp = castRange<URange<MetaType>>(r);
tmp = rangeCast<URange<MetaType>>(r);
}
else {
tmp = r;
tmp = std::dynamic_pointer_cast<URange<MetaType>>(r);
}
CXZ_ASSERT(tmp->size() == S, "cannot cast range of size " << tmp->size()
<< " into static range of size " << S);

5
src/include/ranges/srange.h
View file

@ -10,7 +10,7 @@
namespace CNORXZ
{
template <typename Meta, SizeT S>
template <typename MetaT, SizeT S>
class SIndex : public IndexInterface<SIndex<MetaT,S>,MetaT>
{
public:
@ -18,6 +18,8 @@ namespace CNORXZ
typedef SRange<MetaT,S> RangeType;
typedef MetaT MetaType;
INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
DEFAULT_MEMBERS(SIndex);
SIndex(const RangePtr& range, SizeT pos = 0);
SIndex& operator=(SizeT lexpos);
@ -119,6 +121,7 @@ namespace CNORXZ
{
static Sptr<SRange<MetaType,S>> func(const RangePtr& r);
};
}
#endif

10
src/include/ranges/urange.h
View file

@ -8,6 +8,8 @@
#include "ranges/range_base.h"
#include "xpr/xpr.h"
#include <iterator>
namespace CNORXZ
{
@ -20,13 +22,18 @@ namespace CNORXZ
typedef URange<MetaT> RangeType;
typedef MetaT MetaType;
INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
DEFAULT_MEMBERS(UIndex);
UIndex(const RangePtr& range, SizeT pos = 0);
void swap(UIndex& i) {}; // !!!
UIndex& operator=(SizeT lexpos);
UIndex& operator++();
UIndex& operator--();
UIndex operator+(Int n) const;
UIndex operator-(Int n) const;
SizeT operator-(const UIndex& i) const { return lex() - i.lex(); } // !!!
UIndex& operator+=(Int n);
UIndex& operator-=(Int n);
@ -62,6 +69,9 @@ namespace CNORXZ
const MetaT* mMetaPtr;
};
template <typename MetaT>
void swap(UIndex<MetaT>& a, UIndex<MetaT>& b) { a.swap(b); }
template <typename MetaType, class I1>
decltype(auto) operator*(const Sptr<UIndex<MetaType>>& a, const Sptr<I1>& b);

3
src/include/ranges/yrange.h
View file

@ -19,10 +19,11 @@ namespace CNORXZ
typedef YRange RangeType;
typedef Vector<DType> MetaType;
INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
YIndex() = default;
YIndex(YIndex&& i) = default;
YIndex& operator=(YIndex&& i) = default;
// no defaults:
YIndex(const YIndex& i);
YIndex& operator=(const YIndex& i);

19
src/tests/operation_unit_test.cc
View file

@ -98,9 +98,10 @@ namespace
{
protected:
typedef MIndex<CIndex,LIndex<CIndex,2>,EIndex<SizeT,4,1>> MCCI;
typedef MIndex<CIndex,LIndex<CIndex,2>,EIndex<SizeT,4,1>> MCCI1;
typedef MIndex<LIndex<CIndex,2>,EIndex<SizeT,4,1>,CIndex> MCCI2;
OpCont_CR_CR_Test()
OpCont_CR_CR_Test2()
{
mSize1 = 12;
mSize2 = 11;
@ -115,8 +116,8 @@ namespace
mCI1j = std::make_shared<CIndex>(cr1);
mCI2i = std::make_shared<CIndex>(cr2);
mCI2j = std::make_shared<CIndex>(cr2);
mCC1i1j = mindexPtr(mCI1i*eplex(mCI1j,4,1,2));
mCC1j1i = mindexPtr(eplex(mCI1j,4,1,2)*mCI1i);
mCC1i1j = mindexPtr(mCI1i*eplex<4,1,2>(mCI1j));
mCC1j1i = mindexPtr(eplex<4,1,2>(mCI1j)*mCI1i);
mOC1i1j.init(mCC1i1j);
mOR1j1i.init(mData11.data(), mCC1j1i);
mOR1i1j.init(mData11.data(), mCC1i1j);
@ -132,11 +133,11 @@ namespace
Sptr<CIndex> mCI1j;
Sptr<CIndex> mCI2i;
Sptr<CIndex> mCI2j;
Sptr<MCCI> mCC1i1j;
Sptr<MCCI> mCC1j1i;
OpCont<double,MCCI> mOC1i1j;
COpRoot<double,MCCI> mOR1j1i;
COpRoot<double,MCCI> mOR1i1j;
Sptr<MCCI1> mCC1i1j;
Sptr<MCCI2> mCC1j1i;
OpCont<double,MCCI1> mOC1i1j;
COpRoot<double,MCCI2> mOR1j1i;
COpRoot<double,MCCI1> mOR1i1j;
};
TEST_F(OpCont_CR_Test, Basics)