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

index format + slice

Browse source
This commit is contained in:
Christian Zimmermann 2022-12-28 21:21:11 +01:00
parent 16f062b069
commit b86ea957ba
13 changed files with 185 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/include/array/array_base.cc.h
View file

@ -118,7 +118,7 @@ namespace CNORXZ
if(npack.size() == 0){
return nullptr;
}
return mkXIndex(yindexPtr(npack));
return xindexPtr(yindexPtr(npack));
}
/******************

27
src/include/base/iter.cc.h
View file

@ -23,6 +23,33 @@ namespace CNORXZ
{
return iteri(g, f, Isqr<B,E>{});
}
template <SizeT E, SizeT I, class G, class F, class C, typename... Args>
constexpr decltype(auto) iterIfi(const G& g, const F& f, const C& c, const Args&... args)
{
if constexpr(I >= E){
if constexpr(std::is_same<F,NoF>::value){
return;
}
else {
return f(args...);
}
}
else {
if constexpr(c(std::integral_constant<SizeT,I>{})){
return iterIfi<E,I+1>(g, f, c, args..., g(std::integral_constant<SizeT,I>{}));
}
else {
return iterIfi<E,I+1>(g, f, c, args...);
}
}
}
template <SizeT B, SizeT E, class G, class F, class C>
constexpr decltype(auto) iterIf(const G& g, const F& f, const C& c)
{
return iterIfi<E,B>(g, f, c);
}
}
#endif

6
src/include/base/iter.h
View file

@ -12,6 +12,12 @@ namespace CNORXZ
template <SizeT B, SizeT E, class G, class F>
constexpr decltype(auto) iter(const G& g, const F& f);
template <SizeT E, SizeT I, class G, class F, class C, typename... Args>
constexpr decltype(auto) iterIfi(const G& g, const F& f, const C& c, const Args&... args);
template <SizeT B, SizeT E, class G, class F, class C>
constexpr decltype(auto) iterIf(const G& g, const F& f, const C& c);
}
#endif

8
src/include/ranges/dindex.h
View file

@ -54,6 +54,9 @@ namespace CNORXZ
DType meta() const;
DIndex& at(const DType& meta);
Sptr<DIndex> format(const Sptr<DIndex>& ind) const;
Sptr<DIndex> slice(const Sptr<DIndex>& ind) const;
DXpr<SizeT> ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const;
const XIndexPtr& xptr() const;
@ -61,7 +64,10 @@ namespace CNORXZ
private:
XIndexPtr mI;
};
template <>
struct has_sub<DIndex>
{ static constexpr bool value = true; };
}
#endif

62
src/include/ranges/mrange.cc.h
View file

@ -414,29 +414,24 @@ namespace CNORXZ
static_assert(has_sub<Index>::value, "try to format single index");
if constexpr(has_static_sub<Index>::value){
static_assert(index_dim<Index>::value == NI, "got index with conflicting static dimension");
typedef std::remove_reference<decltype(ind->blockSizes())>::type BT;
return iter<0,NI>
( [&](auto i) {
std::get<i>(mIPack)->format(std::get<i>(ind->pack()));
return std::get<i>(mIPack)->format(std::get<i>(ind->pack()));
},
[](const auto&... e) {
return std::make_shared<GMIndex<BT,Indices...>>
(mBlockSizes, e... );
[&](const auto&... e) {
return gmindexPtr(mBlockSizes, e... );
} );
}
else {
typedef Arr<UPos,NI> BT;
auto pack = ind->pack();
CXZ_ASSERT(pack.size() == NI, "attempt to format index of dimension " << NI
<< " using index of dimension " << bs.size());
auto bs = ind->blockSizes();
<< " using index of dimension " << pack.size());
return iter<0,NI>
( [&](auto i) {
return std::get<i>(mIPack)->format(pack[i]);
},
[](const auto&... e) {
return std::make_shared<GMIndex<BlockType,Indices...>>
(mBlockSizes, e... );
[&](const auto&... e) {
return gmindexPtr(mBlockSizes, e... );
} );
}
}
@ -446,6 +441,46 @@ namespace CNORXZ
decltype(auto) GMIndex<BlockType,Indices...>::slice(const Sptr<Index>& ind) const
{
static_assert(is_index<Index>::value, "got non-index type");
static_assert(has_sub<Index>::value, "try to slice single index");
if constexpr(has_static_sub<Index>::value and
((has_static_sub<Indices>::value and ...) or
(not has_sub<Indices>::value and ...)) ){
static_assert(index_dim<Index>::value == NI, "got index with conflicting static dimension");
const auto bs = iterIf<0,NI>
( [&](auto i) { return std::get<i>(mBlockSizes); },
[](const auto&... e) { std::make_tuple(e...); },
[](auto i) {
return std::is_same<typename TupleElem<i>::type,NIndex>::value;
});
return iterIf<0,NI>
( [&](auto i) { return std::get<i>(mIPack)->slice(std::get<i>(ind->pack())); },
[&](const auto&... e) { return gmindex(bs, e... ); },
[](auto i) {
return std::is_same<typename TupleElem<i>::type,NIndex>::value;
} );
}
else {
Vector<SizeT> bs;
Vector<XIndexPtr> ivec;
bs.reserve(NI);
ivec.reserve(NI);
auto pack = ind->pack();
CXZ_ASSERT(pack.size() == NI, "attempt to slice index of dimension " << NI
<< " using index of dimension " << pack.size());
iter<0,NI>
( [&](auto i) {
if(std::get<i>(mIPack)->dim() == 0){
bs.push_back(std::get<i>(mBlockSizes).val());
if constexpr(has_static_sub<Index>::value){
ivec.push_back( xindexPtr( std::get<i>(ind->pack()) ) );
}
else {
ivec.push_back( xindexPtr( ind->pack()[i] ) );
}
}
}, NoF {});
return yindexPtr(bs, ivec);
}
}
template <class BlockType, class... Indices>
@ -523,6 +558,11 @@ namespace CNORXZ
return MIndex<Indices...>(is...);
}
template <class BlockType, class... Indices>
constexpr decltype(auto) gmindexPtr(const BlockType& bs, const Sptr<Indices>&... is)
{
return std::make_shared<GMIndex<BlockType,Indices...>>(bs, is...);
}
/*********************
* MRangeFactory *

4
src/include/ranges/mrange.h
View file

@ -72,7 +72,7 @@ namespace CNORXZ
template <class Index>
decltype(auto) slice(const Sptr<Index>& ind) const;
// -> IndexInterface;
// drop index instance or drop blockSize if that if ind is Null
// drop index instance or drop blockSize of ind if that of *this is not Null
// return result as new instance
template <class Xpr, class F>
@ -152,6 +152,8 @@ namespace CNORXZ
template <class... Indices>
constexpr decltype(auto) mindex(const Sptr<Indices>&... is);
template <class BlockType, class... Indices>
constexpr decltype(auto) gmindexPtr(const BlockType& bs, const Sptr<Indices>&... is);
template <class... Ranges>
class MRangeFactory : public RangeFactoryBase

19
src/include/ranges/urange.cc.h
View file

@ -136,6 +136,25 @@ namespace CNORXZ
{
return UPos(id == this->id() ? 1 : 0);
}
template <typename MetaType>
template <class Index>
decltype(auto) UIndex<MetaType>::format(const Sptr<Index>& ind) const
{
return ind;
}
template <typename MetaType>
template <class Index>
decltype(auto) UIndex<MetaType>::slice(const Sptr<Index>& ind) const
{
if(ind != nullptr){
if(ind->dim() != 0) {
return Sptr<CIndex>();
}
}
return std::make_shared<CIndex>(*this);
}
template <typename MetaType>
template <class Xpr, class F>

6
src/include/ranges/urange.h
View file

@ -47,6 +47,12 @@ namespace CNORXZ
const MetaT& meta() const;
UIndex& at(const MetaT& metaPos);
template <class Index>
decltype(auto) format(const Sptr<Index>& ind) const;
template <class Index>
decltype(auto) slice(const Sptr<Index>& ind) const;
template <class Xpr, class F>
decltype(auto) ifor(const Xpr& xpr, F&& f) const;

28
src/include/ranges/xindex.cc.h
View file

@ -133,7 +133,7 @@ namespace CNORXZ
if constexpr(has_static_sub<Index>::value){
constexpr SizeT D = index_dim<Index>::value;
return iter<0,D>
( [&](auto i) { return mkXIndex(std::get<i>(mI->THIS().pack())); },
( [&](auto i) { return xindexPtr(std::get<i>(mI->THIS().pack())); },
[](const auto&... e) { return Vector<XIndexPtr>({ e ... }); } );
}
else if constexpr(has_sub<Index>::value){
@ -177,7 +177,7 @@ namespace CNORXZ
return nullptr;
}
else {
return mkXIndex(replaceBlockSizes(arr, std::static_pointer_cast<Index>(mI)));
return xindexPtr(replaceBlockSizes(arr, std::static_pointer_cast<Index>(mI)));
}
}
else if constexpr(has_sub<Index>::value) {
@ -209,6 +209,22 @@ namespace CNORXZ
return *this;
}
template <class Index, typename Meta>
Sptr<DIndex> XIndex<Index,Meta>::format(const Sptr<DIndex>& ind) const
{
CXZ_ERROR("IMPLEMENT!!!");
return nullptr;
//return std::make_shared<DIndex>(xindexPtr(mI->format(ind)));
}
template <class Index, typename Meta>
Sptr<DIndex> XIndex<Index,Meta>::slice(const Sptr<DIndex>& ind) const
{
CXZ_ERROR("IMPLEMENT!!!");
return nullptr;
//return std::make_shared<DIndex>(xindexPtr(mI->slice(ind)));
}
template <class Index, typename Meta>
DXpr<SizeT> XIndex<Index,Meta>::ifor(const DXpr<SizeT>& xpr,
std::function<SizeT(SizeT,SizeT)>&& f) const
@ -217,12 +233,18 @@ namespace CNORXZ
}
template <class Index>
XIndexPtr mkXIndex(const Sptr<Index>& i)
inline XIndexPtr xindexPtr(const Sptr<Index>& i)
{
typedef typename Index::MetaType Meta;
return std::make_shared<XIndex<Index,Meta>>
(std::dynamic_pointer_cast<IndexInterface<Index,Meta>>(i));
}
template <>
inline XIndexPtr xindexPtr<XIndexBase>(const Sptr<XIndexBase>& i)
{
return i;
}
}
#endif

17
src/include/ranges/xindex.h
View file

@ -9,10 +9,12 @@
namespace CNORXZ
{
// Future IndexWrapper
class XIndexBase
{
public:
//typedef DType MetaType;
DEFAULT_MEMBERS(XIndexBase);
virtual ~XIndexBase() = default;
virtual XIndexPtr copy() const = 0;
@ -44,6 +46,9 @@ namespace CNORXZ
virtual DType meta() const = 0;
virtual XIndexBase& at(const DType& meta) = 0;
virtual Sptr<DIndex> format(const Sptr<DIndex>& ind) const = 0;
virtual Sptr<DIndex> slice(const Sptr<DIndex>& ind) const = 0;
virtual DXpr<SizeT> ifor(const DXpr<SizeT>& xpr,
std::function<SizeT(SizeT,SizeT)>&& f) const = 0;
@ -96,6 +101,9 @@ namespace CNORXZ
virtual DType meta() const override final;
virtual XIndexBase& at(const DType& meta) override final;
virtual Sptr<DIndex> format(const Sptr<DIndex>& ind) const override final;
virtual Sptr<DIndex> slice(const Sptr<DIndex>& ind) const override final;
virtual DXpr<SizeT> ifor(const DXpr<SizeT>& xpr,
std::function<SizeT(SizeT,SizeT)>&& f) const override final;
@ -109,8 +117,11 @@ namespace CNORXZ
{ static constexpr bool value = true; };
template <class Index>
XIndexPtr mkXIndex(const Sptr<Index>& i);
inline XIndexPtr xindexPtr(const Sptr<Index>& i);
template <>
inline XIndexPtr xindexPtr<XIndexBase>(const Sptr<XIndexBase>& i);
}
#endif

4
src/include/ranges/yrange.h
View file

@ -52,6 +52,9 @@ namespace CNORXZ
DType meta() const;
YIndex& at(const DType& meta);
Sptr<DIndex> format(const Sptr<DIndex>& ind) const;
Sptr<DIndex> slice(const Sptr<DIndex>& ind) const;
DXpr<SizeT> ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const;
YIndex& operator()(const Sptr<YIndex>& i);
@ -87,6 +90,7 @@ namespace CNORXZ
YIndex yindex(const Vector<XIndexPtr>& is);
Sptr<YIndex> yindexPtr(const Vector<XIndexPtr>& is);
Sptr<YIndex> yindexPtr(const Vector<SizeT>& bs, const Vector<XIndexPtr>& is);
class YRangeFactory : public RangeFactoryBase
{

10
src/lib/ranges/dindex.cc
View file

@ -162,6 +162,16 @@ namespace CNORXZ
return *this;
}
Sptr<DIndex> DIndex::format(const Sptr<DIndex>& ind) const
{
return mI->format(ind);
}
Sptr<DIndex> DIndex::slice(const Sptr<DIndex>& ind) const
{
return mI->slice(ind);
}
DXpr<SizeT> DIndex::ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const
{
return DXpr<SizeT>(mI->ifor(xpr, std::forward<std::function<SizeT(SizeT,SizeT)>>(f)) );

12
src/lib/ranges/yrange.cc
View file

@ -339,6 +339,18 @@ namespace CNORXZ
return *this;
}
Sptr<DIndex> YIndex::format(const Sptr<DIndex>& ind) const
{
CXZ_ERROR("IMPLEMENT!!!");
return nullptr;
}
Sptr<DIndex> YIndex::slice(const Sptr<DIndex>& ind) const
{
CXZ_ERROR("IMPLEMENT!!!");
return nullptr;
}
DXpr<SizeT> YIndex::ifor(const DXpr<SizeT>& xpr, std::function<SizeT(SizeT,SizeT)>&& f) const
{
return mkIFor(0, xpr, std::forward<std::function<SizeT(SizeT,SizeT)>>(f));