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

start refactoring dynamic stuff: DExt -> Polymorphism: not finished, does not compile so far...

Browse source
This commit is contained in:
Christian Zimmermann 2020-07-07 16:42:41 +02:00
parent c8d9eb9aa4
commit 4391d3a79a
3 changed files with 104 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/include/multi_array_operation.cc.h
View file

@ -155,6 +155,25 @@ namespace MultiArrayTools
return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
}
template <typename T, class Target, class OpClass>
inline void AssignmentExpr2<T,Target,OpClass>::operator()(size_t mlast, DExt last)
{
(*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
}
template <typename T, class Target, class OpClass>
inline DExt AssignmentExpr2<T,Target,OpClass>::dRootSteps(std::intptr_t iPtrNum) const
{
return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
}
template <typename T, class Target, class OpClass>
inline DExt AssignmentExpr2<T,Target,OpClass>::dExtension() const
{
CHECK;
return nullptr; //???!!!
}
template <typename T, class Target, class OpClass>
AddExpr<T,Target,OpClass>::AddExpr(T* dataPtr, const Target& tar, const OpClass& sec) :
mTar(tar), mSec(sec), mDataPtr(dataPtr) {}
@ -173,7 +192,6 @@ namespace MultiArrayTools
//return mSec.rootSteps(iPtrNum);
}
/****************************
* ConstOperationRoot *
****************************/

9
src/include/multi_array_operation.h
View file

@ -17,6 +17,8 @@
#include "arith.h"
#include "xfor/xfor.h"
namespace MultiArrayTools
{
@ -106,7 +108,7 @@ namespace MultiArrayTools
};
template <typename T, class Target, class OpClass>
class AssignmentExpr2
class AssignmentExpr2 : public ExpressionBase
{
private:
AssignmentExpr2() = default;
@ -128,6 +130,11 @@ namespace MultiArrayTools
inline void operator()(size_t start = 0);
inline void operator()(size_t start, ExtType last);
auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
inline void operator()(size_t mlast, DExt last) override final;
inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
inline DExt dExtension() const override final;
};
//template <typename T, class OpClass>

106
src/include/xfor/xfor.h
View file

@ -21,7 +21,41 @@ namespace MultiArrayHelper
// 'HIDDEN FOR' CLASS for nested for loops in contractions a.s.o.
// (NO COUNTING OF MASTER POSITION !!!!!)
typedef std::pair<size_t const*,size_t> DExt;
//typedef std::pair<size_t const*,size_t> DExt;
class ExtBase
{
public:
ExtBase() = default;
ExtBase(const ExtBase& in) = default;
ExtBase(ExtBase&& in) = default;
ExtBase& operator=(const ExtBase& in) = default;
ExtBase& operator=(ExtBase&& in) = default;
//virtual size_t size() const = 0;
//virtual size_t rootSteps() const = 0;
};
template <class ExtType>
class ExtT : public ExtBase
{
private:
ExtType mExt;
public:
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) {}
//virtual size_t size() const override final;
//virtual size_t rootSteps() const override final;
const ExtType& ext() const { return mExt; }
};
typedef std::shared_ptr<ExtBase> DExt;
inline MExt<void> mkExt(size_t s) { return MExt<void>(s); }
@ -393,7 +427,8 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr, ForType FT>
inline void For<IndexClass,Expr,FT>::operator()(size_t mlast, DExt last)
{
operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
//operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
}
template <class IndexClass, class Expr, ForType FT>
@ -438,16 +473,18 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr, ForType FT>
DExt For<IndexClass,Expr,FT>::dRootSteps(std::intptr_t iPtrNum) const
{
mRootSteps = rootSteps(iPtrNum);
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
//mRootSteps = rootSteps(iPtrNum);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
// sizeof(ExtType)/sizeof(size_t));
}
template <class IndexClass, class Expr, ForType FT>
DExt For<IndexClass,Expr,FT>::dExtension() const
{
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(mExt);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
// sizeof(ExtType)/sizeof(size_t));
}
template <class IndexClass, class Expr, ForType FT>
@ -482,7 +519,8 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr>
inline void PFor<IndexClass,Expr>::operator()(size_t mlast, DExt last)
{
operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
//operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
}
template <class IndexClass, class Expr>
@ -545,16 +583,18 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr>
DExt PFor<IndexClass,Expr>::dRootSteps(std::intptr_t iPtrNum) const
{
mRootSteps = rootSteps(iPtrNum);
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
//mRootSteps = rootSteps(iPtrNum);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
// sizeof(ExtType)/sizeof(size_t));
}
template <class IndexClass, class Expr>
DExt PFor<IndexClass,Expr>::dExtension() const
{
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(mExt);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
// sizeof(ExtType)/sizeof(size_t));
}
/************************
@ -586,7 +626,8 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr>
inline void SingleExpression<IndexClass,Expr>::operator()(size_t mlast, DExt last)
{
operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
//operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
}
template <class IndexClass, class Expr>
@ -628,16 +669,18 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr>
DExt SingleExpression<IndexClass,Expr>::dRootSteps(std::intptr_t iPtrNum) const
{
mRootSteps = rootSteps(iPtrNum);
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
//mRootSteps = rootSteps(iPtrNum);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
// sizeof(ExtType)/sizeof(size_t));
}
template <class IndexClass, class Expr>
DExt SingleExpression<IndexClass,Expr>::dExtension() const
{
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(mExt);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
// sizeof(ExtType)/sizeof(size_t));
}
/****************
@ -670,7 +713,8 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr>
inline void SubExpr<IndexClass,Expr>::operator()(size_t mlast, DExt last)
{
operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
//operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
}
template <class IndexClass, class Expr>
@ -711,16 +755,18 @@ namespace MultiArrayHelper
template <class IndexClass, class Expr>
DExt SubExpr<IndexClass,Expr>::dRootSteps(std::intptr_t iPtrNum) const
{
mRootSteps = rootSteps(iPtrNum);
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
//mRootSteps = rootSteps(iPtrNum);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mRootSteps),
//sizeof(ExtType)/sizeof(size_t));
}
template <class IndexClass, class Expr>
DExt SubExpr<IndexClass,Expr>::dExtension() const
{
return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
sizeof(ExtType)/sizeof(size_t));
return std::make_shared<ExtT<ExtType>>(mExt);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
// sizeof(ExtType)/sizeof(size_t));
}
/***************************
@ -764,9 +810,7 @@ namespace MultiArrayHelper
inline void ExpressionHolder<Expr>::operator()(size_t mlast, ExtType last)
{
mExpr(mlast,
std::make_pair<size_t const*,size_t>
(reinterpret_cast<size_t const*>(&last),
sizeof(ExtType)/sizeof(size_t)));
std::make_shared<ExtT<ExtType>>(last));
}
template <class Expr>
@ -791,14 +835,16 @@ namespace MultiArrayHelper
auto ExpressionHolder<Expr>::rootSteps(std::intptr_t iPtrNum) const
-> ExtType
{
return *reinterpret_cast<ExtType const*>( mExpr.dRootSteps(iPtrNum).first );
return std::dynamic_pointer_cast<ExtT<ExtType>>(*mExpr.dRootSteps(iPtrNum))->ext();
//return *reinterpret_cast<ExtType const*>( mExpr.dRootSteps(iPtrNum).first );
}
template <class Expr>
auto ExpressionHolder<Expr>::extension() const
-> ExtType
{
return *reinterpret_cast<ExtType const*>( mExpr.dExtension().first );
return std::dynamic_pointer_cast<ExtT<ExtType>>(*mExpr.dExtension())->ext();
//return *reinterpret_cast<ExtType const*>( mExpr.dExtension().first );
}