From 4212ed7ee9b1ef0c6ac3defc1842fb346458f785 Mon Sep 17 00:00:00 2001 From: Christian Zimmermann Date: Sun, 18 Sep 2022 00:49:36 +0200 Subject: [PATCH] crange.basic test works --- src/include/base/dtype.cc.h | 6 ++- src/include/base/dtype.h | 2 +- src/include/ranges/index_base.cc.h | 30 +++++++++++++ src/include/ranges/index_base.h | 10 ++++- src/include/ranges/xindex.cc.h | 64 +++++++++++++++++++++++++-- src/include/ranges/xindex.h | 70 ++++++++++++++++++++++-------- src/tests/range_unit_test.cc | 31 +++++++++++++ 7 files changed, 188 insertions(+), 25 deletions(-) diff --git a/src/include/base/dtype.cc.h b/src/include/base/dtype.cc.h index c0d356f..9a34486 100644 --- a/src/include/base/dtype.cc.h +++ b/src/include/base/dtype.cc.h @@ -15,6 +15,7 @@ namespace CNORXZ DType::DType(const T& d) : mD(d) { _mkToStr(); + _mkComp(); } template @@ -22,6 +23,7 @@ namespace CNORXZ { mD = d; _mkToStr(); + _mkComp(); return *this; } @@ -43,10 +45,10 @@ namespace CNORXZ else { auto& at = std::any_cast(a); auto& dt = std::any_cast(mD); - if(std::equal_to(dt,at)){ + if(std::equal_to{}(dt,at)){ return 0; } - else if(std::less(dt,at)){ + else if(std::less{}(dt,at)){ return -1; } else { diff --git a/src/include/base/dtype.h b/src/include/base/dtype.h index 64c4576..fb94791 100644 --- a/src/include/base/dtype.h +++ b/src/include/base/dtype.h @@ -35,7 +35,7 @@ namespace CNORXZ template DType& operator=(const T& d); - std::string str() const { return mToStr(); } + String str() const { return mToStr(); } const std::any& get() const { return mD; } bool operator==(const DType& a) const { return mComp(a.mD) == 0; } diff --git a/src/include/ranges/index_base.cc.h b/src/include/ranges/index_base.cc.h index fade417..52c4b4c 100644 --- a/src/include/ranges/index_base.cc.h +++ b/src/include/ranges/index_base.cc.h @@ -100,6 +100,36 @@ namespace CNORXZ assert(mPtrId == reinterpret_cast(this)); return mPtrId; } + + /**************************** + * Non-member functions * + ****************************/ + + template + IndexPtr& operator++(const IndexPtr& i) + { + ++(*i); + return i; + } + + template + IndexPtr& operator--(const IndexPtr& i) + { + --(*i); + return i; + } + + template + IndexPtr operator+(const IndexPtr& i, Int n) + { + return std::make_shared>( *i + n ); + } + + template + IndexPtr operator-(const IndexPtr& i, Int n) + { + return std::make_shared>( *i - n ); + } } #endif diff --git a/src/include/ranges/index_base.h b/src/include/ranges/index_base.h index 508bc4b..6168954 100644 --- a/src/include/ranges/index_base.h +++ b/src/include/ranges/index_base.h @@ -59,6 +59,9 @@ namespace CNORXZ auto iforh(SizeT step, const Expr ex) const { return THIS().template iforh(step,ex); } */ + protected: + SizeT mPos = 0; + private: friend I; // why not protected???!!! @@ -70,10 +73,15 @@ namespace CNORXZ IndexInterface& operator=(IndexInterface&& in); IndexInterface(SizeT pos); - SizeT mPos = 0; PtrId mPtrId = 0; }; + template + IndexPtr& operator++(const IndexPtr& i); + + template + IndexPtr& operator--(const IndexPtr& i); + // to define relative indices: template IndexPtr operator+(const IndexPtr& i, Int n); diff --git a/src/include/ranges/xindex.cc.h b/src/include/ranges/xindex.cc.h index 1a6f6ad..55c5d9f 100644 --- a/src/include/ranges/xindex.cc.h +++ b/src/include/ranges/xindex.cc.h @@ -6,21 +6,26 @@ namespace CNORXZ { + /************** * XIndex * **************/ template - XIndex::XIndex(const IndexPtr& i) : mI(i) {} + XIndex::XIndex(const IndexPtr& i) : + XIndexBase(i->pos()), + mI(i) {} template XIndex::XIndex(const IndexInterface& i) : + XIndexBase(i.pos()), mI(std::make_shared(i.THIS())) {} template XIndex& XIndex::operator=(SizeT pos) { *mI = pos; + IB::mPos = mI->pos(); return *this; } @@ -28,6 +33,7 @@ namespace CNORXZ XIndex& XIndex::operator++() { ++(*mI); + IB::mPos = mI->pos(); return *this; } @@ -35,19 +41,64 @@ namespace CNORXZ XIndex& XIndex::operator--() { --(*mI); + IB::mPos = mI->pos(); return *this; } + template + Sptr XIndex::operator+(Int n) const + { + return std::make_shared>(*mI + n); + } + + template + Sptr XIndex::operator-(Int n) const + { + return std::make_shared>(*mI - n); + } + + template + XIndex& XIndex::operator+=(Int n) + { + (*mI) += n; + IB::mPos = mI->pos(); + return *this; + } + + template + XIndex& XIndex::operator-=(Int n) + { + (*mI) -= n; + IB::mPos = mI->pos(); + return *this; + } + + template + DType XIndex::operator*() const + { + return DType(*(*mI)); + } + + template + DType XIndex::operator->() const + { + return DType(*(*mI)); + } + template Int XIndex::pp(PtrId idxPtrNum) { - return mI->pp(idxPtrNum); + Int out = mI->pp(idxPtrNum); + IB::mPos = mI->pos(); + return out; } template Int XIndex::mm(PtrId idxPtrNum) { - return mI->mm(idxPtrNum); + Int out = mI->mm(idxPtrNum); + IB::mPos = mI->pos(); + return out; } template @@ -56,6 +107,12 @@ namespace CNORXZ return mI->dim(); } + template + RangePtr XIndex::range() const + { + return mI->range(); + } + template SizeT XIndex::getStepSize(SizeT n) const { @@ -79,6 +136,7 @@ namespace CNORXZ { // check!!! mI->at(std::any_cast(meta.get())); + IB::mPos = mI->pos(); return *this; } /* diff --git a/src/include/ranges/xindex.h b/src/include/ranges/xindex.h index fd9389d..773328c 100644 --- a/src/include/ranges/xindex.h +++ b/src/include/ranges/xindex.h @@ -12,48 +12,82 @@ namespace CNORXZ class XIndexBase : public IndexInterface { public: + typedef IndexInterface IB; + DEFAULT_MEMBERS(XIndexBase); - + XIndexBase(SizeT pos) : IndexInterface(pos) {} + virtual XIndexBase& operator=(SizeT pos) = 0; virtual XIndexBase& operator++() = 0; virtual XIndexBase& operator--() = 0; + virtual Sptr operator+(Int n) const = 0; + virtual Sptr operator-(Int n) const = 0; + virtual XIndexBase& operator+=(Int n) = 0; + virtual XIndexBase& operator-=(Int n) = 0; + + virtual DType operator*() const = 0; + virtual DType operator->() const = 0; + virtual Int pp(PtrId idxPtrNum) = 0; virtual Int mm(PtrId idxPtrNum) = 0; - virtual size_t dim() const = 0; - virtual size_t getStepSize(SizeT n) const = 0; + + virtual SizeT dim() const = 0; + virtual RangePtr range() const = 0; + virtual SizeT getStepSize(SizeT n) const = 0; + virtual String stringMeta() const = 0; virtual DType meta() const = 0; virtual XIndexBase& at(const DType& meta) = 0; + //virtual DExpr ifor(SizeT step, DExpr ex) const = 0; //virtual DExpr iforh(SizeT step, DExpr ex) const = 0; // ...!!! }; + //Sptr& operator++(Sptr& i); + //Sptr& operator--(Sptr& i); + // MultiIndex Wrapper: template class XIndex : public XIndexBase { - private: - IndexPtr mI; - public: + typedef XIndexBase XIB; + typedef XIB::IB IB; + DEFAULT_MEMBERS(XIndex); XIndex(const IndexPtr& i); XIndex(const IndexInterface& i); - virtual XIndex& operator=(SizeT pos) override; - virtual XIndex& operator++() override; - virtual XIndex& operator--() override; - virtual Int pp(PtrId idxPtrNum) override; - virtual Int mm(PtrId idxPtrNum) override; - virtual SizeT dim() const override; - virtual SizeT getStepSize(SizeT n) const override; - virtual String stringMeta() const override; - virtual DType meta() const override; - virtual XIndexBase& at(const DType& meta) override; - //virtual DExpr ifor(SizeT step, DExpr ex) const override; - //virtual DExpr iforh(SizeT step, DExpr ex) const override; + virtual XIndex& operator=(SizeT pos) override final; + virtual XIndex& operator++() override final; + virtual XIndex& operator--() override final; + virtual Sptr operator+(Int n) const override final; + virtual Sptr operator-(Int n) const override final; + virtual XIndex& operator+=(Int n) override final; + virtual XIndex& operator-=(Int n) override final; + + virtual DType operator*() const override final; + virtual DType operator->() const override final; + + virtual Int pp(PtrId idxPtrNum) override final; + virtual Int mm(PtrId idxPtrNum) override final; + + virtual SizeT dim() const override final; + virtual RangePtr range() const override final; + virtual SizeT getStepSize(SizeT n) const override final; + + virtual String stringMeta() const override final; + virtual DType meta() const override final; + virtual XIndexBase& at(const DType& meta) override final; + + //virtual DExpr ifor(SizeT step, DExpr ex) const override final; + //virtual DExpr iforh(SizeT step, DExpr ex) const override final; // ....!!!! + + private: + IndexPtr mI; + }; } diff --git a/src/tests/range_unit_test.cc b/src/tests/range_unit_test.cc index b7b58df..877269f 100644 --- a/src/tests/range_unit_test.cc +++ b/src/tests/range_unit_test.cc @@ -27,9 +27,40 @@ namespace { TEST_F(CR_Test, Basics) { auto cr = CRangeFactory(mSize).create(); + auto crx = std::dynamic_pointer_cast(cr); EXPECT_EQ(cr->size(), mSize); + EXPECT_EQ(crx->size(), mSize); + + EXPECT_EQ(crx->begin() != crx->end(), true); + EXPECT_EQ(crx->begin().pos(), 0); + EXPECT_EQ(crx->end().pos(), mSize); + + EXPECT_EQ(*cr->begin() != *cr->end(), true); + EXPECT_EQ(cr->begin()->pos(), 0); + EXPECT_EQ(cr->end()->pos(), mSize); + + + SizeT cnt = 0; + auto endxi = cr->end(); + for(auto xi = cr->begin(); *xi != *endxi; ++(*xi)){ + EXPECT_EQ(xi->pos(), cnt); + EXPECT_EQ(*(*xi), cnt); + ++cnt; + } + + SizeT cnt2 = 0; + for(auto x: *crx){ + EXPECT_EQ(x, cnt2++); + } + } // UR_Test // RCast_Test } + +int main(int argc, char** argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}