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

slice utilities

Browse source
This commit is contained in:
Christian Zimmermann 2018-09-11 18:38:30 +02:00
parent 91acb873e1
commit de6b80a90b
2 changed files with 58 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/include/helper_tools.h
View file

@ -6,6 +6,7 @@
#include "slice.h" #include "slice.h"
#include <ostream> #include <ostream>
#include "pack_num.h" #include "pack_num.h"
#include <functional>
namespace MultiArrayTools namespace MultiArrayTools
{ {
@ -48,6 +49,9 @@ namespace MultiArrayTools
template <size_t N, class MArray> template <size_t N, class MArray>
auto prtr(const MArray& ma) auto prtr(const MArray& ma)
-> decltype(ma.template getRangePtr<N>()); -> decltype(ma.template getRangePtr<N>());
template <class IndexType>
inline void For(const std::shared_ptr<IndexType>& ind, const std::function<void(void)>& ll);
} }
/* ========================= * /* ========================= *
@ -139,6 +143,14 @@ namespace MultiArrayTools
return ma.template getRangePtr<N>(); return ma.template getRangePtr<N>();
} }
template <class IndexType>
inline void For(const std::shared_ptr<IndexType>& ind, const std::function<void(void)>& ll)
{
for((*ind) = 0; ind->pos() != ind->max(); ++(*ind)){
ll();
}
}
} }
#endif #endif

52
src/include/multi_array_operation.h
View file

@ -50,9 +50,13 @@ namespace MultiArrayTools
-> Operation<T,divides<T>,OperationClass,Second>; -> Operation<T,divides<T>,OperationClass,Second>;
template <class IndexType> template <class IndexType>
auto c(std::shared_ptr<IndexType>& ind) const auto c(const std::shared_ptr<IndexType>& ind) const
-> Contraction<T,OperationClass,IndexType>; -> Contraction<T,OperationClass,IndexType>;
template <class... Indices>
auto sl(const std::shared_ptr<Indices>&... inds) const
-> ConstSlice<T,typename Indices::RangeType...>;
private: private:
friend OperationClass; friend OperationClass;
friend OperationTemplate<T,OperationClass>; friend OperationTemplate<T,OperationClass>;
@ -153,12 +157,14 @@ namespace MultiArrayTools
template <class Expr> template <class Expr>
Expr loop(Expr exp) const; Expr loop(Expr exp) const;
const T* data() const;
private: private:
//MultiArrayBase<T,Ranges...> const& mArrayRef; //MultiArrayBase<T,Ranges...> const& mArrayRef;
const T* mDataPtr; const T* mDataPtr;
IndexType mIndex; mutable IndexType mIndex;
//std::shared_ptr<MultiArrayBase<T,Ranges...> > mMaPtr; //std::shared_ptr<MultiArrayBase<T,Ranges...> > mMaPtr;
}; };
@ -257,11 +263,15 @@ namespace MultiArrayTools
T* data() const; T* data() const;
template <class... Indices>
auto sl(const std::shared_ptr<Indices>&... inds)
-> Slice<T,typename Indices::RangeType...>;
private: private:
//MutableMultiArrayBase<T,Ranges...>& mArrayRef; //MutableMultiArrayBase<T,Ranges...>& mArrayRef;
T* mDataPtr; T* mDataPtr;
IndexType mIndex; mutable IndexType mIndex;
}; };
template <typename T> template <typename T>
@ -454,12 +464,22 @@ namespace MultiArrayTools
template <typename T, class OperationClass> template <typename T, class OperationClass>
template <class IndexType> template <class IndexType>
auto OperationBase<T,OperationClass>::c(std::shared_ptr<IndexType>& ind) const auto OperationBase<T,OperationClass>::c(const std::shared_ptr<IndexType>& ind) const
-> Contraction<T,OperationClass,IndexType> -> Contraction<T,OperationClass,IndexType>
{ {
return Contraction<T,OperationClass,IndexType>(THIS(), ind); return Contraction<T,OperationClass,IndexType>(THIS(), ind);
} }
template <typename T, class OperationClass>
template <class... Indices>
auto OperationBase<T,OperationClass>::sl(const std::shared_ptr<Indices>&... inds) const
-> ConstSlice<T,typename Indices::RangeType...>
{
ConstSlice<T,typename Indices::RangeType...> out(inds->range()...);
out.define(inds...) = *this;
return out;
}
/***************************************** /*****************************************
* OperationMaster::AssignmentExpr * * OperationMaster::AssignmentExpr *
*****************************************/ *****************************************/
@ -567,6 +587,12 @@ namespace MultiArrayTools
return mDataPtr[pos.val()]; return mDataPtr[pos.val()];
} }
template <typename T, class... Ranges>
const T* ConstOperationRoot<T,Ranges...>::data() const
{
return mDataPtr + mIndex().pos();
}
template <typename T, class... Ranges> template <typename T, class... Ranges>
MExt<void> ConstOperationRoot<T,Ranges...>::rootSteps(std::intptr_t iPtrNum) const MExt<void> ConstOperationRoot<T,Ranges...>::rootSteps(std::intptr_t iPtrNum) const
{ {
@ -697,9 +723,23 @@ namespace MultiArrayTools
template <typename T, class... Ranges> template <typename T, class... Ranges>
T* OperationRoot<T,Ranges...>::data() const T* OperationRoot<T,Ranges...>::data() const
{ {
return mDataPtr + mIndex.pos(); return mDataPtr + mIndex().pos();
} }
template <typename T, class... Ranges>
template <class... Indices>
auto OperationRoot<T,Ranges...>::sl(const std::shared_ptr<Indices>&... inds)
-> Slice<T,typename Indices::RangeType...>
{
Slice<T,typename Indices::RangeType...> out(inds->range()...);
out.define(inds...) = *this;
return out;
}
/************************
* OperationValue *
************************/
template <typename T> template <typename T>
OperationValue<T>::OperationValue(const T& val) : mVal(val) {} OperationValue<T>::OperationValue(const T& val) : mVal(val) {}