198 lines
6.9 KiB
C++
198 lines
6.9 KiB
C++
|
|
#include "dynamic_operation.h"
|
|
#include "helper_tools.h"
|
|
|
|
namespace MultiArrayTools
|
|
{
|
|
template <typename T, class Operation>
|
|
T DynamicOperation<T,Operation>::get(const DExtT& pos) const
|
|
{
|
|
return mOp.get(pos.expl<ET>());
|
|
}
|
|
|
|
template <typename T, class Operation>
|
|
DynamicOperationBase<T>& DynamicOperation<T,Operation>::set(const DExtT& pos)
|
|
{
|
|
mOp.set(pos.expl<ET>());
|
|
return *this;
|
|
}
|
|
|
|
template <typename T, class Operation>
|
|
DExtT DynamicOperation<T,Operation>::rootSteps(std::intptr_t iPtrNum) const
|
|
{
|
|
return DExtT(mkDExt(mkExtT(mOp.rootSteps(iPtrNum))),None(0));
|
|
}
|
|
|
|
template <typename T, class Operation>
|
|
DynamicExpression DynamicOperation<T,Operation>::loop(const DynamicExpression& exp) const
|
|
{
|
|
return mOp.loop(exp);
|
|
}
|
|
|
|
template <typename T, class Operation>
|
|
const T* DynamicOperation<T,Operation>::data() const
|
|
{
|
|
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);
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const DynamicOuterOp& in) :
|
|
mThreadId(omp_get_thread_num()), mOp(in.mOp),
|
|
mIndices(in.mIndices),
|
|
mMa((mThreadId != in.mThreadId) ? std::make_shared<MultiArray<T,Ranges...>>(*in.mMa) : in.mMa),
|
|
mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto),
|
|
mL((mThreadId != in.mThreadId) ?
|
|
mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
|
|
std::make_tuple(mMa),
|
|
std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(mIndices) )),
|
|
std::array<size_t,1>({1}), std::array<size_t,1>({0})) :
|
|
in.mL)
|
|
|
|
{*mMa = 0;}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(DynamicOuterOp&& in) :
|
|
mThreadId(omp_get_thread_num()), mOp(in.mOp),
|
|
mIndices(in.mIndices),
|
|
mMa((mThreadId != in.mThreadId) ? std::make_shared<MultiArray<T,Ranges...>>(*in.mMa) : in.mMa),
|
|
mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto),
|
|
mL((mThreadId != in.mThreadId) ?
|
|
mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
|
|
std::make_tuple(mMa),
|
|
std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(mIndices) )),
|
|
std::array<size_t,1>({1}), std::array<size_t,1>({0})) :
|
|
in.mL)
|
|
|
|
{*mMa = 0;}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicOuterOp<T,Operation,Ranges...>&
|
|
DynamicOuterOp<T,Operation,Ranges...>::operator=(const DynamicOuterOp& in)
|
|
{
|
|
mThreadId = omp_get_thread_num();
|
|
mOp = in.mOp;
|
|
mIndices = in.mIndices;
|
|
if(mThreadId != in.mThreadId){
|
|
mMa = std::make_shared<MultiArray<T,Ranges...>>(in.mMa);
|
|
mProto = OperationRoot<T,Ranges...>(*mMa,mIndices);
|
|
mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
|
|
std::make_tuple(mMa),
|
|
std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(mIndices) )),
|
|
std::array<size_t,1>({1}), std::array<size_t,1>({0}));
|
|
}
|
|
else {
|
|
mMa = in.mMa;
|
|
mProto = in.mProto;
|
|
mL = in.mL;
|
|
}
|
|
*mMa = 0;
|
|
return *this;
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicOuterOp<T,Operation,Ranges...>&
|
|
DynamicOuterOp<T,Operation,Ranges...>::operator=(DynamicOuterOp&& in)
|
|
{
|
|
mThreadId = omp_get_thread_num();
|
|
mOp = in.mOp;
|
|
mIndices = in.mIndices;
|
|
if(mThreadId != in.mThreadId){
|
|
mMa = std::make_shared<MultiArray<T,Ranges...>>(in.mMa);
|
|
mProto = OperationRoot<T,Ranges...>(*mMa,mIndices);
|
|
mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
|
|
std::make_tuple(mMa),
|
|
std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(mIndices) )),
|
|
std::array<size_t,1>({1}), std::array<size_t,1>({0}));
|
|
}
|
|
else {
|
|
mMa = in.mMa;
|
|
mProto = in.mProto;
|
|
mL = in.mL;
|
|
}
|
|
*mMa = 0;
|
|
return *this;
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const Operation& op,
|
|
const std::shared_ptr<typename Ranges::IndexType>&... inds)
|
|
: mThreadId(omp_get_thread_num()), mOp(op),
|
|
mIndices(inds...),
|
|
mMa(std::make_shared<MultiArray<T,Ranges...>>(mkArray<T>(inds->range()...))),
|
|
mProto(OperationRoot<T,Ranges...>(*mMa,inds...)),
|
|
mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
|
|
std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),
|
|
std::array<size_t,1>({1}), std::array<size_t,1>({0}))
|
|
{}
|
|
|
|
/*
|
|
DynamicOuterOp(const std::shared_ptr<DynamicOperationBase<OpH<OperationRoot<typename Operatrion::value_type,Ranges...>>>>& dyn,
|
|
const Operation& op, const std::shared_ptr<Indices>&... inds )
|
|
: mThreadId(omp_get_thread_num()),
|
|
//mDyn(dyn),
|
|
mOp(op), mIndices(inds...),
|
|
mMa(std::make_shared<MultiArray<T,Ranges...>>(mkArray<T>(inds->range()...))),
|
|
mProto(OperationRoot<T,Ranges...>(*mMa,inds...)),
|
|
mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
|
|
std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),
|
|
std::array<size_t,1>({1}), std::array<size_t,1>({0}))
|
|
{}
|
|
*/
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
OpH<OperationRoot<T,Ranges...>> DynamicOuterOp<T,Operation,Ranges...>::get(const DExtT& pos) const
|
|
{
|
|
//if(mPrev) mPrev.get(pos.expl<ET>());
|
|
mL(0,pos.expl<ET>());
|
|
return mProto; // empty
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicOperationBase<OpH<OperationRoot<T,Ranges...>>>&
|
|
DynamicOuterOp<T,Operation,Ranges...>::set(const DExtT& pos)
|
|
{
|
|
mOp.set(pos.expl<ET>());
|
|
return *this;
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DExtT DynamicOuterOp<T,Operation,Ranges...>::rootSteps(std::intptr_t iPtrNum) const
|
|
{
|
|
return DExtT(mkDExt(mkExtT(mL.rootSteps(iPtrNum))),None(0));
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
DynamicExpression DynamicOuterOp<T,Operation,Ranges...>::loop(const DynamicExpression& exp) const
|
|
{
|
|
return mOp.loop(exp); // ???!!
|
|
}
|
|
|
|
template <typename T, class Operation, class... Ranges>
|
|
const OpH<OperationRoot<T,Ranges...>>* DynamicOuterOp<T,Operation,Ranges...>::data() const
|
|
{
|
|
return &mProto;
|
|
}
|
|
/*
|
|
template <class Op1, class Op2>
|
|
template <class ET>
|
|
inline T TwoOp<Op1,Op2>::get(const ET& pos) const
|
|
{
|
|
return mOp2.get(pos);
|
|
|
|
}
|
|
|
|
*/
|
|
template <typename T, class Operation, class... Ranges>
|
|
std::shared_ptr<DynamicOperationBase<OpH<OperationRoot<T,Ranges...>>>>
|
|
DynamicOuterOp<T,Operation,Ranges...>::deepCopy() const
|
|
{
|
|
return std::make_shared<DynamicOuterOp<T,Operation,Ranges...>>(*this);
|
|
}
|
|
|
|
} // namespace MultiArrayTools
|