op4utest works

This commit is contained in:
Christian Zimmermann 2020-08-24 16:35:14 +02:00
parent d7436ed577
commit d2e7cb3a63
5 changed files with 69 additions and 21 deletions

View file

@ -6,7 +6,6 @@ namespace MultiArrayTools
template <typename T, class Operation> template <typename T, class Operation>
const T& DynamicOperation<T,Operation>::get(const DExtT& pos) const const T& DynamicOperation<T,Operation>::get(const DExtT& pos) const
{ {
VCHECK(pos.expl<ET>().val());
return mOp.get(pos.expl<ET>()); return mOp.get(pos.expl<ET>());
} }
@ -20,7 +19,7 @@ namespace MultiArrayTools
template <typename T, class Operation> template <typename T, class Operation>
DExtT DynamicOperation<T,Operation>::rootSteps(std::intptr_t iPtrNum) const DExtT DynamicOperation<T,Operation>::rootSteps(std::intptr_t iPtrNum) const
{ {
return mOp.rootSteps(iPtrNum); return DExtT(mkDExt(mkExtT(mOp.rootSteps(iPtrNum))),None(0));
} }
template <typename T, class Operation> template <typename T, class Operation>
@ -35,5 +34,11 @@ namespace MultiArrayTools
return mOp.data(); return mOp.data();
} }
template <typename T, class Operation>
std::shared_ptr<DynamicOperationBase<T>> DynamicOperation<T,Operation>::deepCopy() const
{
return std::make_shared<DynamicOperation<T,Operation>>(*this);
}
} // namespace MultiArrayTools } // namespace MultiArrayTools

View file

@ -29,6 +29,7 @@ namespace MultiArrayTools
virtual DExtT rootSteps(std::intptr_t iPtrNum = 0) const = 0; virtual DExtT rootSteps(std::intptr_t iPtrNum = 0) const = 0;
virtual DynamicExpression loop(const DynamicExpression& exp) const = 0; virtual DynamicExpression loop(const DynamicExpression& exp) const = 0;
virtual const T* data() const = 0; virtual const T* data() const = 0;
virtual std::shared_ptr<DynamicOperationBase<T>> deepCopy() const = 0;
}; };
@ -38,7 +39,8 @@ namespace MultiArrayTools
private: private:
Operation mOp; Operation mOp;
public: public:
typedef decltype(std::declval<Operation>().rootSteps()) ET; typedef decltype(mOp.rootSteps()) ET;
//typedef decltype(std::declval<Operation>().rootSteps()) ET;
DynamicOperation() = default; DynamicOperation() = default;
DynamicOperation(const DynamicOperation& in) = default; DynamicOperation(const DynamicOperation& in) = default;
@ -53,6 +55,7 @@ namespace MultiArrayTools
virtual DExtT rootSteps(std::intptr_t iPtrNum = 0) const override final; virtual DExtT rootSteps(std::intptr_t iPtrNum = 0) const override final;
virtual DynamicExpression loop(const DynamicExpression& exp) const override final; virtual DynamicExpression loop(const DynamicExpression& exp) const override final;
virtual const T* data() const override final; virtual const T* data() const override final;
virtual std::shared_ptr<DynamicOperationBase<T>> deepCopy() const override final;
}; };
template <typename T> template <typename T>
@ -69,15 +72,16 @@ namespace MultiArrayTools
static constexpr bool CONT = true; static constexpr bool CONT = true;
DynamicO() = default; DynamicO() = default;
DynamicO(const DynamicO& in) = default; DynamicO(const DynamicO& in) : mOp(in.mOp->deepCopy()) {}
DynamicO(DynamicO&& in) = default; DynamicO(DynamicO&& in) : mOp(in.mOp->deepCopy()) {}
DynamicO& operator=(const DynamicO& in) = default; DynamicO& operator=(const DynamicO& in) { mOp = in.mOp->deepCopy(); }
DynamicO& operator=(DynamicO&& in) = default; DynamicO& operator=(DynamicO&& in) { mOp = in.mOp->deepCopy(); }
template <class Op> template <class Op>
DynamicO(const Op& op) : mOp(std::make_shared<DynamicOperation<T,Op>>(op)) {} DynamicO(const Op& op) : mOp(std::make_shared<DynamicOperation<T,Op>>(op)) {}
inline const T& get(const DExtT& pos) const { return mOp->get(pos); } template <class X>
inline const T& get(const DExtTX<X>& pos) const { return mOp->get(pos.reduce()); }
inline DynamicO& set(const DExtT& pos) { return mOp->set(pos); } inline DynamicO& set(const DExtT& pos) { return mOp->set(pos); }
inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return mOp->rootSteps(iPtrNum); } inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return mOp->rootSteps(iPtrNum); }
inline DynamicExpression loop(const DynamicExpression& exp) const { return mOp->loop(exp); } inline DynamicExpression loop(const DynamicExpression& exp) const { return mOp->loop(exp); }

View file

@ -181,6 +181,7 @@ namespace MultiArrayTools
template <typename T, class Target, class OpClass, OpIndexAff OIA> template <typename T, class Target, class OpClass, OpIndexAff OIA>
inline void AssignmentExpr2<T,Target,OpClass,OIA>::operator()(size_t start, ExtType last) inline void AssignmentExpr2<T,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
{ {
//CHECK;
mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next()); mDataPtr[OpIndexResolve<OIA>::get(start,last)] = mSec.get(last.next());
} }

View file

@ -41,6 +41,7 @@ namespace MultiArrayHelper
} }
}; };
struct None;
template <class X> template <class X>
class MExt class MExt
@ -86,12 +87,14 @@ namespace MultiArrayHelper
{ return Getter<N>::getX(*this); } { return Getter<N>::getX(*this); }
inline MExt operator+(const MExt& in) const; inline MExt operator+(const MExt& in) const;
inline MExt operator+(const None& in) const;
inline MExt operator*(size_t in) const; inline MExt operator*(size_t in) const;
template <class Y> template <class Y>
auto extend(const Y& y) const -> MExt<decltype(mNext.extend(y))> auto extend(const Y& y) const -> MExt<decltype(mNext.extend(y))>
{ return MExt<decltype(mNext.extend(y))>(mExt, mNext.extend(y)); } { return MExt<decltype(mNext.extend(y))>(mExt, mNext.extend(y)); }
std::string stype() const { return std::string("E[") + mNext.stype() + "]"; }
}; };
struct None struct None
@ -117,6 +120,8 @@ namespace MultiArrayHelper
template <class Y> template <class Y>
Y extend(const Y& y) const Y extend(const Y& y) const
{ return y; } { return y; }
std::string stype() const { return std::string("N"); }
}; };
template <> template <>
@ -164,12 +169,15 @@ namespace MultiArrayHelper
{ return Getter<N>::getX(*this); } { return Getter<N>::getX(*this); }
inline MExt operator+(const MExt& in) const; inline MExt operator+(const MExt& in) const;
inline MExt operator+(const None& in) const;
inline MExt operator*(size_t in) const; inline MExt operator*(size_t in) const;
template <class Y> template <class Y>
auto extend(const Y& y) const -> MExt<Y> auto extend(const Y& y) const -> MExt<Y>
{ return MExt<Y>(mExt,y); } { return MExt<Y>(mExt,y); }
std::string stype() const { return std::string("E[N]"); }
}; };
@ -231,6 +239,12 @@ namespace MultiArrayHelper
return MExt<X>(mExt + in.val(), mNext + in.next()); return MExt<X>(mExt + in.val(), mNext + in.next());
} }
template <class X>
inline MExt<X> MExt<X>::operator+(const None& in) const
{
return *this;
}
template <class X> template <class X>
inline MExt<X> MExt<X>::operator*(size_t in) const inline MExt<X> MExt<X>::operator*(size_t in) const
{ {
@ -279,6 +293,11 @@ namespace MultiArrayHelper
return MExt<None>(mExt + in.val()); return MExt<None>(mExt + in.val());
} }
inline MExt<None> MExt<None>::operator+(const None& in) const
{
return *this;
}
//template <> //template <>
inline MExt<None> MExt<None>::operator*(size_t in) const inline MExt<None> MExt<None>::operator*(size_t in) const
{ {

View file

@ -44,6 +44,7 @@ namespace MultiArrayHelper
template <class ExtType> template <class ExtType>
const ExtType& expl() const; const ExtType& expl() const;
virtual std::string stype() const = 0;
}; };
typedef std::shared_ptr<ExtBase> DExt; typedef std::shared_ptr<ExtBase> DExt;
@ -75,12 +76,26 @@ namespace MultiArrayHelper
virtual void zero() override final { mExt.zero(); } virtual void zero() override final { mExt.zero(); }
virtual DExt operator+(const ExtBase& in) const override final virtual DExt operator+(const ExtBase& in) const override final
{ return std::make_shared<ExtT>( mExt + dynamic_cast<const ExtT&>(in).mExt ); } { return std::make_shared<ExtT<ExtType>>( mExt + dynamic_cast<const ExtT<ExtType>&>(in).mExt ); }
virtual DExt operator*(size_t in) const override final virtual DExt operator*(size_t in) const override final
{ return std::make_shared<ExtT>( mExt * in ); } { return std::make_shared<ExtT<ExtType>>( mExt * in ); }
virtual std::string stype() const override final { return std::string("T[") + mExt.stype() + "]"; }
}; };
//class DExtT; //class DExtT;
template <class ExtType>
DExt mkDExt(const ExtT<ExtType>& in)
{
return std::make_shared<ExtT<ExtType>>(in);
}
template <class ExtType>
ExtT<ExtType> mkExtT(const ExtType& in)
{
return ExtT<ExtType>(in);
}
template <class X> template <class X>
class DExtTX class DExtTX
{ {
@ -96,24 +111,26 @@ namespace MultiArrayHelper
DExtTX(DExtTX&& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {} DExtTX(DExtTX&& in) : mDExt(in.mDExt->deepCopy()), mNext(in.mNext) {}
DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); } DExtTX& operator=(const DExtTX& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); }
DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); } DExtTX& operator=(DExtTX&& in) { mNext = in.mNext; mDExt = in.mDExt->deepCopy(); }
DExtTX(const DExt& in) : mDExt(in) {} explicit DExtTX(const DExt& in) : mDExt(in) {}
/*
template <class Y> template <class Y>
DExtTX& operator=(const Y& y) { mDExt = std::make_shared<ExtT<Y>>(y); return *this; } DExtTX& operator=(const Y& y) { mDExt = std::make_shared<ExtT<Y>>(y); return *this; }
template <class Y> template <class Y>
DExtTX(const Y& y) : mDExt(std::make_shared<ExtT<Y>>(y)) {} DExtTX(const Y& y) : mDExt(std::make_shared<ExtT<Y>>(y)) {}
*/
DExtTX(const DExt& y, const X& x) : mDExt(y), explicit DExtTX(const DExt& y, const X& x) : mDExt(y->deepCopy()),
mNext(x) {} mNext(x) {}
virtual size_t size() const { return mDExt->size(); } virtual size_t size() const { return mDExt->size(); }
inline const DExt& get() const { return mDExt; } inline const DExt& get() const { return mDExt; }
inline DExtTX<None> reduce() const { return DExtTX<None>(mDExt,None(0)); }
inline DExtTX operator+(const DExtTX& in) const inline DExtTX operator+(const DExtTX& in) const
{ if (not mDExt) return in; else return DExtTX( (*mDExt) + (*in.mDExt) ) ; } { if (not mDExt) return in; else return DExtTX( (*mDExt) + (*in.mDExt), mNext + in.mNext ); }
inline DExtTX operator*(size_t in) const inline DExtTX operator*(size_t in) const
{ if (not mDExt) return *this; else return DExtTX( (*mDExt) * in ) ; } { if (not mDExt) return *this; else return DExtTX((*mDExt) * in, mNext * in); }
template <class ExtType> template <class ExtType>
inline const ExtType& expl() const inline const ExtType& expl() const
@ -131,6 +148,8 @@ namespace MultiArrayHelper
template <size_t N> template <size_t N>
inline auto nn() const -> decltype(Getter<N>::getX(*this)) inline auto nn() const -> decltype(Getter<N>::getX(*this))
{ return Getter<N>::getX(*this); } { return Getter<N>::getX(*this); }
std::string stype() const { return std::string("D[") + mDExt->stype() + "," + mNext.stype() + "]"; }
}; };
typedef DExtTX<None> DExtT; typedef DExtTX<None> DExtT;
@ -438,8 +457,8 @@ namespace MultiArrayHelper
inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final; inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
inline DExt dExtension() const override final; inline DExt dExtension() const override final;
inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return dRootSteps(iPtrNum); } inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return DExtT(dRootSteps(iPtrNum)); }
inline DExtT extension() const { return dExtension(); } inline DExtT extension() const { return DExtT(dExtension()); }
}; };