From 796bb501185ba0bcc9a60f1c7d6976c2c74c70e3 Mon Sep 17 00:00:00 2001 From: Christian Zimmermann Date: Mon, 12 Sep 2022 16:48:45 +0200 Subject: [PATCH] ext -> pos, expressions... --- src/include/base/obj_handle.cc.h | 3 + src/include/base/obj_handle.h | 5 +- src/include/base/types.h | 20 ++ src/include/ranges/xfor/exttype.h | 405 +++++++++++++----------------- src/include/ranges/xfor/xfor.h | 71 ++++-- 5 files changed, 251 insertions(+), 253 deletions(-) diff --git a/src/include/base/obj_handle.cc.h b/src/include/base/obj_handle.cc.h index 58a5084..cd2dbb7 100644 --- a/src/include/base/obj_handle.cc.h +++ b/src/include/base/obj_handle.cc.h @@ -13,6 +13,9 @@ namespace CNORXZ template ObjHandle::ObjHandle(const T& a) : mC(std::make_unique(a)) {} + template + ObjHandle::ObjHandle(const Uptr& a) : mC(a) {} + template ObjHandle::ObjHandle(const ObjHandle& a) : mC(std::make_unique(*a.mC)) {} diff --git a/src/include/base/obj_handle.h b/src/include/base/obj_handle.h index 96a7f9b..0e5817f 100644 --- a/src/include/base/obj_handle.h +++ b/src/include/base/obj_handle.h @@ -12,13 +12,14 @@ namespace CNORXZ template class ObjHandle { - private: - std::unique_ptr mC; + protected: + Uptr mC; public: ObjHandle(); ObjHandle(const T& a); + ObjHandle(const Uptr& a); ObjHandle(const ObjHandle& a); ObjHandle(ObjHandle&& a); ObjHandle& operator=(const ObjHandle& a); diff --git a/src/include/base/types.h b/src/include/base/types.h index 535641e..3ae7fed 100644 --- a/src/include/base/types.h +++ b/src/include/base/types.h @@ -63,6 +63,26 @@ namespace CNORXZ template class Allocator; + // definition: ranges/xfor/exttype.h + class VPosBase; + + // definition: ranges/xfor/exttype.h + template + class PosInterface; + + // definition: ranges/xfor/exttype.h + class DPos; + + // definition: ranges/xfor/exttype.h + class VPos; + + // definition: ranges/xfor/exttype.h + template + class MPos; + + // definition: ranges/xfor/exttype.h + class NPos; + // definition: ranges/range_base.h class RangeBase; diff --git a/src/include/ranges/xfor/exttype.h b/src/include/ranges/xfor/exttype.h index 76a12bd..a38efd1 100644 --- a/src/include/ranges/xfor/exttype.h +++ b/src/include/ranges/xfor/exttype.h @@ -10,126 +10,161 @@ namespace CNORXZInternal // Dynamic Ext: ObjHandl // In For Expr: try to resolve until some upper limit - struct None; - - class ExtBase + class VPosBase { public: - ExtBase() = default; - ExtBase(const ExtBase& in) = default; - ExtBase(ExtBase&& in) = default; - ExtBase& operator=(const ExtBase& in) = default; - ExtBase& operator=(ExtBase&& in) = default; + DEFAULT_MEMBERS(VPosBase); - virtual size_t size() const = 0; - virtual const size_t& val() const = 0; - virtual bool operator==(const ExtBase& in) const = 0; - virtual bool operator==(size_t in) const = 0; - - virtual std::shared_ptr operator+(const ExtBase& in) const = 0; - virtual std::shared_ptr operator*(size_t in) const = 0; - virtual void zero() = 0; - - virtual std::shared_ptr deepCopy() const = 0; - - template - const ExtType& expl() const; - + virtual SizeT vsize() const = 0; + virtual const SizeT& vval() const = 0; + virtual VPosBase& vzero() = 0; + virtual Uptr vextend(const DPos& a) const = 0; + virtual Uptr vextend(const MPos& a) const = 0; }; - typedef std::shared_ptr DExt; + template + class PosInterface + { + public: + DEFAULT_MEMBERS(PosInterface); - template - class ExtT : public ExtBase + PosT& THIS() { return static_cast(*this); } + const PosT& THIS() const { return static_cast(*this); } + + inline SizeT size() const { THIS().size(); } + inline const SizeT& val() const { THIS().val(); } + inline auto next() const { THIS().next(); } + inline bool operator==(const PosInterface& a) const { return val() == a.val() and next() == a.next(); } + inline bool operator!=(const PosInterface& a) const { return val() != a.val() or next() != a.next(); } + inline bool operator==(SizeT a) const { return val() == a and next() == a; } + inline bool operator!=(SizeT a) const { return val() != a or next() != a; } + inline PosInterface operator+(const PosInterface& a) const { return PosT(val()+a.val(), next()+a.next()); } + inline PosInterface operator*(SizeT a) const { return PosT(val()*a, next()*a); } + inline PosInterface& zero() { return THIS().zero(); } + + template + inline auto extend(const PosInterface

& a) const { return THIS().extend(a); } + }; + + class DPos : public ObjHandle, + public PosInterface + { + public: + DEFAULT_MEMBERS(DPos); + DPos(Uptr a) : ObjHandle(a) {} + + template + DPos(const PosT& a) : ObjHandle( std::make_unique(a) ) {} + + inline SizeT size() const { return mC->vsize(); } + inline const SizeT& val() const { return mC->vval(); } + inline DPos& zero() { mC->vzero(); return *this; } + + template + inline DPos extend(const PosInterface

& a) const + { /* append MPos in static for loop over entries */ } + }; + + /* + template + class VPos : public VPosBase { private: - ExtType mExt; + PosT mExt; public: - static constexpr size_t SIZE = ExtType::SIZE; - static constexpr size_t NUM = ExtType::NUM; - - ExtT() = default; - ExtT(const ExtT& in) = default; - ExtT(ExtT&& in) = default; - ExtT& operator=(const ExtT& in) = default; - ExtT& operator=(ExtT&& in) = default; - ExtT(const ExtType& in) : mExt(in) {} + DEFAULT_MEMBERS(VPos); - virtual std::shared_ptr deepCopy() const override final { return std::make_shared>(mExt); } + VPos(const PosT& in) : mExt(in) {} - virtual size_t size() const override final { return sizeof(ExtType)/sizeof(size_t); } - const ExtType& ext() const { return mExt; } - virtual const size_t& val() const override final { return mExt.val(); } + virtual SizeT size() const override final { return sizeof(PosT)/sizeof(size_t); } + //const PosT& ext() const { return mExt; } + virtual const SizeT& val() const override final { return mExt.val(); } virtual void zero() override final { mExt.zero(); } - virtual bool operator==(const ExtBase& in) const override final - { return mExt == dynamic_cast&>(in).mExt; } + virtual bool operator==(const VPosBase& in) const override final + { return mExt == dynamic_cast&>(in).mExt; } - virtual bool operator==(size_t in) const override final + virtual bool operator==(SizeT in) const override final { return mExt == in; } - virtual DExt operator+(const ExtBase& in) const override final - { return std::make_shared>( mExt + dynamic_cast&>(in).mExt ); } + virtual DExt operator+(const VPosBase& in) const override final + { return std::make_shared>( mExt + dynamic_cast&>(in).mExt ); } virtual DExt operator*(size_t in) const override final - { return std::make_shared>( mExt * in ); } + { return std::make_shared>( mExt * in ); } + + }; + */ + template + class VPos : public VPosBase, public PosT + { + public: + + DEFAULT_MEMBERS(VPos); + + VPos(const PosInterface& a) : PosT(a.THIS()) {} + + virtual SizeT vsize() const override final { return THIS().size(); } + virtual const SizeT& vval() const override final { return THIS().val(); } + virtual VPos& vzero() override final { THIS().zero(); return *this; } + virtual Uptr vextend(const DPos& a) const override final + { return std::make_unique( THIS().extend(a) ); } + virtual Uptr vextend(const MPos& a) const override final + { return std::make_unique( THIS().extend(a) ); } // ??? if that works it would be a miracle ??? + // .... probably I need to define a static instanciation limit... }; - template - DExt mkDExt(const ExtT& in) + template + DPos mkDExt(const VPos& in) { - return std::make_shared>(in); + return std::make_shared>(in); } - template - ExtT mkExtT(const ExtType& in) + template + VPos mkVPos(const PosT& in) { - return ExtT(in); + return VPos(in); } - template - class MExt + template + class MPos { private: - size_t mExt = 0u; - X mNext; + SizeT mExt = 0u; + PosT mNext; public: - static constexpr size_t NUM = X::SIZE; - static constexpr size_t SIZE = NUM + 1; + //static constexpr SizeT NUM = PosT::SIZE; + //static constexpr SizeT SIZE = NUM + 1; - MExt() = default; - MExt(const MExt& in) = default; - MExt& operator=(const MExt& in) = default; - MExt(MExt&& in) = default; - MExt& operator=(MExt&& in) = default; - - inline MExt(size_t ext, X next); + DEFAULT_MEMBERS(MPos); + + inline MPos(SizeT ext, PosT next); template - inline MExt(size_t y, const Z& z); + inline MPos(SizeT y, const Z& z); template - inline MExt(const Y& y, const Z& z); + inline MPos(const Y& y, const Z& z); template - inline MExt(const std::array& arr); + inline MPos(const Arr& arr); template - inline MExt(const MExt& y); + inline MPos(const MPos& y); inline void zero(); - inline const size_t& val() const; - inline const X& next() const; + inline const SizeT& val() const; + inline const PosT& next() const; template inline auto nn() const; - inline bool operator==(const MExt& in) const + inline bool operator==(const MPos& in) const { return mExt == in.mExt and mNext == in.mNext; } @@ -139,89 +174,71 @@ namespace CNORXZInternal return mExt == in and mNext == in; } - inline MExt operator+(const MExt& in) const; - inline MExt operator+(const None& in) const; - inline MExt operator*(size_t in) const; + inline MPos operator+(const MPos& in) const; + inline MPos operator+(const NPos& in) const; + inline MPos operator*(size_t in) const; template - auto extend(const Y& y) const -> MExt - { return MExt(mExt, mNext.extend(y)); } + auto extend(const Y& y) const -> MPos + { return MPos(mExt, mNext.extend(y)); } - std::string stype() const { return std::string("E[") + mNext.stype() + "]"; } }; - struct None + class NPos : public PosInterface { - size_t VAL = 0; - None() = default; - None(const None& in) = default; - None(None&& in) = default; - None& operator=(const None& in) = default; - None& operator=(None&& in) = default; - + private: + SizeT VAL = 0; + public: + + DEFAULT_MEMBERS(NPos); + template - None(const Y& y) {} + NPos(const Y& y) {} - static constexpr size_t SIZE = 0; + //static constexpr SizeT SIZE = 0; - inline bool operator==(const None& in) const - { - return true; - } - - inline bool operator==(size_t in) const - { - return true; // CHECK!!! - } - - inline None operator+(const None& in) const { return None(); } - inline None operator*(size_t in) const { return None(); } - - inline const size_t& val() const { assert(0); return VAL; } + inline const SizeT& val() const { assert(0); return VAL; } + inline bool operator==(const NPos& in) const { return true; } + inline bool operator==(SizeT in) const { return true; } + inline NPos operator+(const NPos& in) const { return NPos(); } + inline NPos operator*(size_t in) const { return NPos(); } inline void zero() {} template Y extend(const Y& y) const { return y; } - std::string stype() const { return std::string("N"); } }; template <> - class MExt + class MPos : public PosInterface> { private: - - size_t mExt = 0u; + SizeT mExt = 0u; public: - - static constexpr size_t NUM = 0; - static constexpr size_t SIZE = NUM + 1; + //static constexpr size_t NUM = 0; + //static constexpr size_t SIZE = NUM + 1; - MExt() = default; - MExt(const MExt& in) = default; - MExt& operator=(const MExt& in) = default; - MExt(MExt&& in) = default; - MExt& operator=(MExt&& in) = default; + DEFAULT_MEMBERS(MPos); - inline MExt(size_t ext); + inline MPos(size_t ext); - inline MExt(size_t y, const None& z) : mExt(y) {} + inline MPos(size_t y, const NPos& z) : mExt(y) {} template - inline MExt(size_t y, const Z& z); + inline MPos(size_t y, const Z& z); template - inline MExt(const Y& y, const Z& z); + inline MPos(const Y& y, const Z& z); template - inline MExt(const std::array& arr); + inline MPos(const std::array& arr); template - inline MExt(const MExt& y); + inline MPos(const MPos& y); - inline bool operator==(const MExt& in) const + inline bool operator==(const MPos& in) const { return mExt == in.mExt; } @@ -232,94 +249,28 @@ namespace CNORXZInternal } inline const size_t& val() const; - inline None next() const { return None(); } + inline NPos next() const { return NPos(); } inline void zero(); template inline auto nn() const; - inline MExt operator+(const MExt& in) const; - inline MExt operator+(const None& in) const; - inline MExt operator*(size_t in) const; + inline MPos operator+(const MPos& in) const; + inline MPos operator+(const NPos& in) const; + inline MPos operator*(size_t in) const; template - auto extend(const Y& y) const -> MExt - { return MExt(mExt,y); } - - std::string stype() const { return std::string("E[N]"); } + auto extend(const Y& y) const -> MPos + { return MPos(mExt,y); } }; - - template - class DExtTX - { - private: - mutable DExt mDExt; - X mNext; - - template - friend class DExtTX; - public: - static constexpr size_t NUM = X::SIZE; - static constexpr size_t SIZE = NUM + 1; - - DExtTX() { mDExt = std::make_shared>(); } - DExtTX(const DExtTX& in) : mNext(in.mNext) - { mDExt = in.mDExt->deepCopy(); } - DExtTX(DExtTX&& in) : mNext(in.mNext) - { mDExt = in.mDExt->deepCopy(); } - DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; } - DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); return *this; } - explicit DExtTX(const DExt& in) : mDExt(in) {} - - bool operator==(const DExtTX& in) const - { return *mDExt == *in.mDExt and mNext == in.mNext; } - - bool operator==(size_t in) const - { return *mDExt == in and mNext == in; } - - template - DExtTX(const DExtTX& in) : mDExt(in.mDExt), mNext(in.mNext) {} - - DExtTX(const DExt& y, const X& x) : mDExt(y->deepCopy()), - mNext(x) {} - - virtual size_t size() const { return mDExt->size(); } - inline const DExt& get() const { return mDExt; } - - inline DExtTX reduce() const { return DExtTX(mDExt,None(0)); } - - inline DExtTX operator+(const DExtTX& in) const - { if (not mDExt) return in; else return DExtTX( (*mDExt) + (*in.mDExt), mNext + in.mNext ); } - inline DExtTX operator*(size_t in) const - { if (not mDExt) return *this; else return DExtTX((*mDExt) * in, mNext * in); } - - template - inline const ExtType& expl() const - { if(mDExt == nullptr) mDExt = std::make_shared>(); assert(mDExt != nullptr); return mDExt->expl(); } - - template - inline auto extend(const Y& y) const -> DExtTX - { return DExtTX(mDExt, mNext.extend(y)); } - - inline const size_t& val() const { return mDExt->val(); } - inline const X& next() const { return mNext; } - - inline void zero() { mDExt->zero(); } - - template - inline auto nn() const; - - }; - - typedef DExtTX DExtT; - inline MExt mkExt(size_t s) { return MExt(s); } + inline MPos mkExt(SizeT s) { return MPos(s); } template - auto getX(const MExt& et) + auto getX(const MPos& et) { if constexpr(I == 0){ return et; @@ -330,7 +281,7 @@ namespace CNORXZInternal } template - auto getX(const DExtTX& et) + auto getX(const DVPosX& et) { if constexpr(I == 0){ return et; @@ -341,26 +292,26 @@ namespace CNORXZInternal } template - auto getX(const None& et) + auto getX(const NPos& et) { static_assert(I == 0); return et; } template - size_t get(const MExt& et) + size_t get(const MPos& et) { return getX(et).get(); } template - size_t get(const DExtTX& et) + size_t get(const DVPosX& et) { return getX(et).get(); } template - size_t get(const None& et) + size_t get(const NPos& et) { return getX(et).get(); } @@ -375,42 +326,42 @@ namespace CNORXZInternal { template - inline MExt::MExt(size_t ext, X next) : mExt(ext), mNext(next) {} + inline MPos::MPos(size_t ext, X next) : mExt(ext), mNext(next) {} template template - inline MExt::MExt(const std::array& arr) : + inline MPos::MPos(const std::array& arr) : mExt(std::get(arr)), mNext(arr) {} template template - inline MExt::MExt(size_t y, const Z& z) : + inline MPos::MPos(size_t y, const Z& z) : mExt(z.val()), mNext(z.val(), z.next()) {} template template - inline MExt::MExt(const Y& y, const Z& z) : + inline MPos::MPos(const Y& y, const Z& z) : mExt(y.val()), mNext(y.next(), z) {} template template - inline MExt::MExt(const MExt& y) : + inline MPos::MPos(const MPos& y) : mExt(y.val()), mNext(y.next()) {} template - inline const size_t& MExt::val() const + inline const size_t& MPos::val() const { return mExt; } template - inline const X& MExt::next() const + inline const X& MPos::next() const { return mNext; } template - inline void MExt::zero() + inline void MPos::zero() { mExt = 0u; mNext.zero(); @@ -418,91 +369,91 @@ namespace CNORXZInternal template template - inline auto MExt::nn() const + inline auto MPos::nn() const { return getX(*this); } template - inline MExt MExt::operator+(const MExt& in) const + inline MPos MPos::operator+(const MPos& in) const { - return MExt(mExt + in.val(), mNext + in.next()); + return MPos(mExt + in.val(), mNext + in.next()); } template - inline MExt MExt::operator+(const None& in) const + inline MPos MPos::operator+(const NPos& in) const { return *this; } template - inline MExt MExt::operator*(size_t in) const + inline MPos MPos::operator*(size_t in) const { - return MExt(mExt * in, mNext * in); + return MPos(mExt * in, mNext * in); } //template <> - inline MExt::MExt(size_t ext) : mExt(ext) {} + inline MPos::MPos(size_t ext) : mExt(ext) {} //template <> template - inline MExt::MExt(size_t y, const Z& z) : + inline MPos::MPos(size_t y, const Z& z) : mExt(z.val()) {} //template <> template - inline MExt::MExt(const Y& y, const Z& z) : + inline MPos::MPos(const Y& y, const Z& z) : mExt(y.val()) {} //template <> template - inline MExt::MExt(const std::array& arr) : + inline MPos::MPos(const std::array& arr) : mExt(std::get(arr)) {} template - inline MExt::MExt(const MExt& y) : + inline MPos::MPos(const MPos& y) : mExt(y.val()) {} //template <> - inline void MExt::zero() + inline void MPos::zero() { mExt = 0u; } template - inline auto MExt::nn() const + inline auto MPos::nn() const { return getX(*this); } - inline const size_t& MExt::val() const + inline const size_t& MPos::val() const { return mExt; } //template <> - inline MExt MExt::operator+(const MExt& in) const + inline MPos MPos::operator+(const MPos& in) const { - return MExt(mExt + in.val()); + return MPos(mExt + in.val()); } - inline MExt MExt::operator+(const None& in) const + inline MPos MPos::operator+(const NPos& in) const { return *this; } //template <> - inline MExt MExt::operator*(size_t in) const + inline MPos MPos::operator*(size_t in) const { - return MExt(mExt * in); + return MPos(mExt * in); } template template - inline auto DExtTX::nn() const + inline auto DVPosX::nn() const { return getX(*this); } diff --git a/src/include/ranges/xfor/xfor.h b/src/include/ranges/xfor/xfor.h index 62dd797..4f91140 100644 --- a/src/include/ranges/xfor/xfor.h +++ b/src/include/ranges/xfor/xfor.h @@ -14,39 +14,62 @@ namespace CNORXZ // 'HIDDEN FOR' CLASS for nested for loops in contractions a.s.o. // (NO COUNTING OF MASTER POSITION !!!!!) - template - class ExpressionInterface + template + class ExprInterface { public: - DEFAULT_MEMBERS(ExpressionInterface); + DEFAULT_MEMBERS(ExprInterface); - Expr& THIS() { return static_cast(*this); } - const Expr& THIS() const { return static_cast(*this); } + Xpr& THIS() { return static_cast(*this); } + const Xpr& THIS() const { return static_cast(*this); } - Sptr copy() const { THIS().copy(); } + //Sptr copy() const { THIS().copy(); } - void operator(SizeT mlast, Pos last) { THIS()(mlast, last); } - void operator(SizeT mlast = 0) { THIS()(mlast); } + void operator()(SizeT mlast, PosT last) { THIS()(mlast, last); } + void operator()(SizeT mlast = 0) { THIS()(mlast); } - Pos rootSteps(PtrId ptrId = 0) const { return THIS().rootSteps(ptrId); } - Pos extension() const { return THIS().extenrion(); } + PosT rootSteps(PtrId ptrId = 0) const { return THIS().rootSteps(ptrId); } + PosT extension() const { return THIS().extenrion(); } }; - class XprBase : public ExpressionInterface + class VExprBase { public: + DEFAULT_MEMBERS(VExprBase); - DEFAULT_MEMBERS(XprBase); + virtual void vexec(SizeT mlast, PosT last) = 0; + virtual void vexec(SizeT mlast) = 0; - virtual Sptr copy() const = 0; - - virtual void operator()(SizeT mlast, DExt last) = 0; - virtual void operator()(SizeT mlast) = 0; - - virtual DExt rootSteps(PtrId iPtrNum = 0) const = 0; - virtual DExt extension() const = 0; + virtual DPos vrootSteps(PtrId ptrId) const = 0; + virtual DPos vextension() const = 0; }; + template + class VExpr : public VExprBase, public Xpr + { + public: + DEFAULT_MEMBERS(VExpr); + VExpr(const ExprInterface& a) : Xpr(a.THIS()) {} + + virtual void vexec(SizeT mlast, PosT last) override final { THIS()(mlast,last); } + virtual void vexec(SizeT mlast) override final { THIS()(mlast); } + + virtual DPos vrootSteps(PtrId ptrId) const override final { return THIS().rootSteps(ptrId); } + virtual DPos vextension() const override final { return THIS().extension(); } + }; + + class DExpr : public ObjHandle, + public ExprInterface + { + public: + DEFAULT_MEMBERS(DExpr); + + inline void operator()(SizeT mlast, DPos last) { mC->vexec(mlast, last); } + inline void operator()(SizeT mlast) { mC->vexec(mlast); } + + inline DPos rootSteps(PtrId ptrId) const { return mC->vrootSteps(ptrId); } + inline DPos extension() const { return mC->vextension(); } + }; template struct PosForward @@ -100,7 +123,7 @@ namespace CNORXZ static constexpr size_t LAYER = Expr::LAYER + 1; static constexpr size_t SIZE = Expr::SIZE + 1; - static constexpr size_t NHLAYER = Expr::NHLAYER + 1; + //static constexpr size_t NHLAYER = Expr::NHLAYER + 1; DEFAULT_MEMBERS_X(SubExpr); @@ -121,7 +144,7 @@ namespace CNORXZ auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType; auto extension() const -> ExtType; }; - + /* template struct NHLayer { @@ -151,7 +174,7 @@ namespace CNORXZ return Expr::LAYER; } }; - + */ template class For : public ExpressionBase { @@ -175,8 +198,8 @@ namespace CNORXZ static constexpr size_t LAYER = Expr::LAYER + 1; static constexpr size_t SIZE = Expr::SIZE; - static constexpr size_t MAX = RangeType::SIZE / DIV; - static constexpr size_t NHLAYER = (FT == ForType::HIDDEN) ? 0 : Expr::NHLAYER + 1; + //static constexpr size_t MAX = RangeType::SIZE / DIV; + //static constexpr size_t NHLAYER = (FT == ForType::HIDDEN) ? 0 : Expr::NHLAYER + 1; DEFAULT_MEMBERS(For);