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

rewrite Operation::get (not final solution)

Browse source
This commit is contained in:
Christian Zimmermann 2021-04-11 22:11:20 +02:00
parent 9d85f8df46
commit 44f6149a23
3 changed files with 85 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1,5 +1,7 @@
#include "multi_array_operation.h"
#include "xfor/exttype.h"
/* ========================= *
* --- TEMPLATE CODE --- *
@ -978,16 +980,38 @@ namespace MultiArrayTools
mOps(ops...),
mF(ff)
{
static_assert( not FISSTATIC, "using instance of function supposed to be static" );
static_assert( not FISSTATIC, "using instance of static function" );
}
template <typename T, class OpFunction, class... Ops>
template <size_t I, size_t J, class ET>
inline auto Operation<T,OpFunction,Ops...>::getSubX(ET pos) const
{
// somehow get rid of the second condition (should NOT be needed if everything is correct)
if constexpr(I == J or sizeof...(Ops)-1 == I){
return std::get<J>(mOps.mOps).get(pos);
}
else {
typedef typename std::remove_reference<decltype(std::get<I>(mOps.mOps))>::type
NextOpType;
return getSubX<I+1,J>(getX<NextOpType::SIZE>(pos));
}
}
template <typename T, class OpFunction, class... Ops>
template <class ET>
inline auto Operation<T,OpFunction,Ops...>::get(ET pos) const
{
typedef std::tuple<Ops...> OpTuple;
return PackNum<sizeof...(Ops)-1>::
template mkOpExpr<SIZE,ET,OpTuple,OpFunction>(mF, pos, mOps.mOps);
auto cre = [&](auto... args)
{
if constexpr(OpFunction::FISSTATIC){
return OpFunction::apply(args...);
}
else {
return (*mF)(args...);
}
};
return MA_CFOR2(i,0,sizeof...(Ops),i+1,return getSub<i>(pos);,cre);
}
template <typename T, class OpFunction, class... Ops>

6
src/include/multi_array_operation.h
View file

@ -803,6 +803,12 @@ namespace MultiArrayTools
Operation(const Ops&... ops);
Operation(std::shared_ptr<OpFunction> ff, const Ops&... ops);
template <size_t I, size_t J, class ET>
inline auto getSubX(ET pos) const;
template <size_t J, class ET>
inline auto getSub(ET pos) const { return getSubX<0,J>(pos); }
template <class ET>
inline auto get(ET pos) const;

104
src/include/statics/static_for.h
View file

@ -6,67 +6,65 @@
namespace MultiArrayTools
{
template <size_t BEG, size_t END, int OFF>
struct sfor
template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Conc>
inline auto sfor(Incr incr, F f, Conc conc)
{
template <typename Incr, typename F, typename Conc>
static inline auto exec(Incr incr, F f, Conc conc)
{
constexpr auto idx = std::integral_constant<size_t, BEG>{};
constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
// "this turns out to be a static endless loop");
auto tmp = f(idxm);
if constexpr(incr(idx) == END){
return tmp;
}
else {
return conc(tmp, sfor<incr(idx),END,OFF>::exec(incr,f,conc));
}
constexpr auto idx = std::integral_constant<size_t, BEG>{};
constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
// "this turns out to be a static endless loop");
auto tmp = f(idxm);
if constexpr(incr(idx) == END){
return tmp;
}
else {
return conc(tmp, sfor<incr(idx),END,OFF>(incr,f,conc));
}
}
template <typename Incr, typename F, typename Conc, typename Arg>
static inline auto exec(Incr incr, F f, Conc conc, const Arg& arg)
{
constexpr auto idx = std::integral_constant<size_t, BEG>{};
constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
// "this turns out to be a static endless loop");
auto tmp = f(idxm);
if constexpr(incr(idx) == END){
return conc(tmp, arg);
}
else {
return conc(tmp, sfor<incr(idx),END,OFF>::exec(incr,f,conc,arg));
}
template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Conc, typename Arg>
inline auto sfor(Incr incr, F f, Conc conc, const Arg& arg)
{
constexpr auto idx = std::integral_constant<size_t, BEG>{};
constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
// "this turns out to be a static endless loop");
auto tmp = f(idxm);
if constexpr(incr(idx) == END){
return conc(tmp, arg);
}
else {
return conc(tmp, sfor<incr(idx),END,OFF>(incr,f,conc,arg));
}
}
template <typename Incr, typename F, typename Create, typename... Args>
static inline auto unpack(Incr incr, F f, Create create, const Args&... args)
{
constexpr auto idx = std::integral_constant<size_t, BEG>{};
constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
// "this turns out to be a static endless loop");
auto tmp = f(idxm);
if constexpr(BEG == END){
return create(args...);
}
else {
return sfor<incr(idx),END,OFF>::unpack(incr, f, create, args..., tmp);
}
template <size_t BEG, size_t END, int OFF, typename Incr, typename F, typename Create, typename... Args>
inline auto unpack(Incr incr, F f, Create create, const Args&... args)
{
constexpr auto idx = std::integral_constant<size_t, BEG>{};
constexpr auto idxm = std::integral_constant<size_t, BEG+OFF>{};
//static_assert(abs(idx.value - END) >= abs(incr(idx) - END),
// "this turns out to be a static endless loop");
if constexpr(BEG == END){
return create(args...);
}
};
else {
auto tmp = f(idxm);
return unpack<incr(idx),END,OFF>(incr, f, create, args..., tmp);
}
}
}
#define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
#define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>::exec([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
#define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
#define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
#define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>::exec([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
#define MA_CFOR(i,beg,end,incr,expr,cre) sfor<beg,end,0>::unpack([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
#define MA_SFOR(i,beg,end,incr,expr) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
#define MA_SCFOR(i,beg,end,incr,expr,conc) sfor<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
#define MA_SRFOR(i,beg,end,decr,expr) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ expr return 0; }, [&](auto f, auto next) { return 0; })
#define MA_SCRFOR(i,beg,end,decr,expr,conc) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); })
#define MA_SCRAFOR(i,beg,end,decr,expr,conc,arg) sfor<beg,end,-1>([&](auto i) constexpr { return decr; }, [&](auto i){ return expr; }, [&](auto f, auto next) { return f.conc(next); }, arg)
#define MA_CFOR(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, [&](auto... args) { return cre(args...); })
#define MA_CFOR2(i,beg,end,incr,expr,cre) unpack<beg,end,0>([&](auto i) constexpr { return incr; }, [&](auto i){ expr }, cre)
#define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>::exec([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
#define MA_SCFOR_X(i,beg,end,incr,expr,conc) sfor<beg,end,0>([](auto i) constexpr { return incr; }, [](auto i){ return expr; }, [](auto f, auto next) { return f.conc(next); })
#endif