corrections + remove old files + some todos

This commit is contained in:
Christian Zimmermann 2023-11-01 01:23:32 +01:00
parent 0e616f8370
commit 636c1d6407
12 changed files with 19 additions and 901 deletions

View file

@ -56,20 +56,9 @@ namespace CNORXZ
decltype(auto) xpr(const Sptr<I>& _this) const { return THIS().xpr(_this); }
RangePtr prange(const IndexInterface& end) const { return THIS().prange(end.THIS()); }
/*
template <class Index>
decltype(auto) formatTo(const Sptr<Index>& ind) const { return ind->formatFrom(THIS()); }
template <class Index>
decltype(auto) formatFrom(const Index& ind) const // yes this is const,
// changes only MIndex/YIndex format, in this case we can just copy the pointers to the sub-index instances
{ return THIS().formatFrom(ind); }
*/
decltype(auto) deepFormat() const { return THIS().deepFormat(); }
//template <class Index>
//decltype(auto) slice(const Sptr<Index>& ind) const { return THIS().slice(ind); }
template <class Xpr, class F = NoF>
decltype(auto) ifor(const Xpr& xpr, F&& f) const
{ return THIS().ifor(xpr,std::forward<F>(f)); }

View file

@ -604,8 +604,20 @@ namespace CNORXZ
template <class... Ranges>
MArray<RangePtr> MRange<Ranges...>::sub() const
{
CXZ_ERROR("not implemented (SRange missing!!)"); //!!!
return MArray<RangePtr>();
// TODO: ZRange (meta and index pos static!)
if constexpr(NR == 0) {
return MArray<RangePtr>();
}
else {
RangePtr sr = SRangeFactory<SizeT,NR>
( iter<0,NR>
( [](auto i) { return i; },
[](auto... x) { return Arr<SizeT,NR> { x... }; } ) ).create();
return MArray<RangePtr>
( sr, iter<0,NR>
( [&](auto i) { return std::get<i>(mRs); },
[](auto... x) { return Vector<RangePtr> ({ x... }); } ) );
}
}
template <class... Ranges>

View file

@ -1,96 +0,0 @@
#ifdef include_range_type
include_range_type(NUL,-2)
#else
#ifdef __cxz_ranges_header__
// assert, that this is only used within range_types/header.h
#ifndef __cxz_range_type_null_def__
#define __cxz_range_type_null_def__
namespace CNORXZ
{
typedef GenSingleIndex<size_t,SpaceType::NUL,0> NullIndex;
std::shared_ptr<GenSingleRange<size_t,SpaceType::NUL,0> > nullr();
std::shared_ptr<NullIndex> nulli();
template <>
class GenSingleRangeFactory<size_t,SpaceType::NUL,0> : public RangeFactoryBase
{
public:
typedef GenSingleRange<size_t,SpaceType::NUL,0> oType;
GenSingleRangeFactory();
std::shared_ptr<RangeBase> create();
friend std::shared_ptr<oType> nullr();
private:
static std::shared_ptr<oType> mRInstance;
};
template <>
class GenSingleRange<size_t,SpaceType::NUL,0> : public RangeInterface<NullIndex>
{
public:
typedef RangeBase RB;
typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::NUL,0> >::IndexType IndexType;
typedef GenSingleRange<size_t,SpaceType::NUL,0> RangeType;
typedef size_t MetaType;
typedef GenSingleRangeFactory<size_t,SpaceType::NUL,0> FType;
virtual size_t size() const final;
virtual size_t dim() const final;
virtual vector<size_t> typeNum() const final;
virtual size_t cmeta(char* target, size_t pos) const final;
virtual size_t cmetaSize() const final;
virtual std::string stringMeta(size_t pos) const final;
virtual vector<char> data() const final;
virtual SpaceType spaceType() const final;
virtual DataHeader dataHeader() const final;
size_t get(size_t pos) const;
size_t getMeta(size_t metapos) const;
virtual IndexType begin() const final;
virtual IndexType end() const final;
//virtual std::shared_ptr<VIWB> index() const final;
friend GenSingleRangeFactory<size_t,SpaceType::NUL,0>;
static constexpr bool defaultable = true;
static constexpr size_t ISSTATIC = 1;
static constexpr size_t SIZE = 1;
static constexpr bool HASMETACONT = false;
static GenSingleRangeFactory<size_t,SpaceType::NUL,0> factory()
{ return GenSingleRangeFactory<size_t,SpaceType::NUL,0>(); }
protected:
GenSingleRange() = default;
GenSingleRange(const GenSingleRange& in) = delete;
//GenSingleRange(size_t spinNum);
};
typedef GenSingleRange<size_t,SpaceType::NUL,0> NullRange;
typedef GenSingleRangeFactory<size_t,SpaceType::NUL,0> NullRF;
std::shared_ptr<NullRF> mkNUL(const char* dp, size_t size);
}
#endif // #ifndef __cxz_range_type_null_def__
#endif // #ifdef __cxz_ranges_header__
#endif // #ifdef include_range_type

View file

@ -325,6 +325,8 @@ namespace CNORXZ
RangePtr PRange<RangeT>::extend(const RangePtr& r) const
{
CXZ_ERROR("implement!!!");
// if r is PRange of same Range, then just add parts
// else derive and add meta of r
return nullptr;
}

View file

@ -51,13 +51,7 @@ namespace CNORXZ
RangePtr prange(const SIndex<MetaType,S>& last) const;
SizeT deepFormat() const;
/*
template <class Index>
decltype(auto) formatFrom(const 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;

View file

@ -147,69 +147,6 @@ namespace CNORXZ
return toVec( mI->deepFormat() );
}
/*
template <class Index, typename Meta>
Vector<XIndexPtr> XIndex<Index,Meta>::pack() const
{
if constexpr(has_static_sub<Index>::value){
constexpr SizeT D = index_dim<Index>::value;
return iter<0,D>
( [&](auto i) { return xindexPtr(std::get<i>(mI->THIS().pack())); },
[](const auto&... e) { return Vector<XIndexPtr>({ e ... }); } );
}
else if constexpr(has_sub<Index>::value){
return mI->THIS().pack();
}
else {
return Vector<XIndexPtr>();
}
}
template <class Index, typename Meta>
Vector<SizeT> XIndex<Index,Meta>::blockSizes() const
{
if constexpr(has_static_sub<Index>::value){
constexpr SizeT D = index_dim<Index>::value;
const auto& bs = mI->THIS().blockSizes();
return iter<0,D>
( [&](auto i) { return std::get<i>(bs); },
[](const auto&... e) { return Vector<SizeT>( { static_cast<SizeT>(e)... } ); } );
}
else if constexpr(has_sub<Index>::value) {
return mI->THIS().blockSizes();
}
else {
return Vector<SizeT>();
}
}
template <class Index, typename Meta>
XIndexPtr XIndex<Index,Meta>::setBlockSizes(const Vector<SizeT>& bs)
{
if constexpr(has_static_sub<Index>::value){
constexpr SizeT D = index_dim<Index>::value;
CXZ_ASSERT(bs.size() == D,
"got block sizes of wrong dimension: " << bs.size() << " vs " << D);
typedef decltype(mI->THIS().blockSizes()) BT;
Arr<UPos,D> arr;
std::copy_n(bs.begin(), D, arr.begin());
if constexpr(std::is_same<BT,Arr<UPos,D>>::value){
mI->THIS().setBlockSizes(arr);
return nullptr;
}
else {
return xindexPtr(replaceBlockSizes(arr, std::static_pointer_cast<Index>(mI)));
}
}
else if constexpr(has_sub<Index>::value) {
mI->THIS().setBlockSizes(bs);
return nullptr;
}
else {
return nullptr;
}
}
*/
template <class Index, typename Meta>
String XIndex<Index,Meta>::stringMeta() const
{
@ -225,7 +162,6 @@ namespace CNORXZ
template <class Index, typename Meta>
XIndexBase& XIndex<Index,Meta>::at(const DType& meta)
{
// check!!!
mI->at(std::any_cast<const Meta&>(meta.get()));
return *this;
}

View file

@ -41,9 +41,6 @@ namespace CNORXZ
virtual UPos stepSize(const IndexId<0>& id) const = 0;
virtual RangePtr prange(const XIndexPtr& last) const = 0;
virtual Vector<SizeT> deepFormat() const = 0;
//virtual Vector<XIndexPtr> pack() const = 0;
//virtual Vector<SizeT> format() const = 0;
//virtual XIndexPtr setBlockSizes(const Vector<SizeT>& bs) = 0;
virtual String stringMeta() const = 0;
virtual DType meta() const = 0;
@ -97,9 +94,6 @@ namespace CNORXZ
virtual UPos stepSize(const IndexId<0>& id) const override final;
virtual RangePtr prange(const XIndexPtr& last) const override final;
virtual Vector<SizeT> deepFormat() const override final;
//virtual Vector<XIndexPtr> pack() const override final;
//virtual Vector<SizeT> format() const override final;
//virtual XIndexPtr setBlockSizes(const Vector<SizeT>& bs) override final;
virtual String stringMeta() const override final;
virtual DType meta() const override final;

View file

@ -179,7 +179,7 @@ namespace CNORXZ
constexpr decltype(auto) operator<<(const PosT& a) const;
};
// treat as scalar pos!!!
// treat as scalar pos!
class DPos : public ObjHandle<VPosBase>
{
public:

View file

@ -1,567 +0,0 @@
#ifndef __cxz_xfor_h__
#define __cxz_xfor_h__
#include <omp.h>
#include "base/base.h"
#include "for_type.h"
#include "for_utils.h"
#include "exttype.h"
namespace CNORXZ
{
// 'HIDDEN FOR' CLASS for nested for loops in contractions a.s.o.
// (NO COUNTING OF MASTER POSITION !!!!!)
/*
template <ForType FT = ForType::DEFAULT>
struct PosForward
{
static inline size_t valuex(size_t last, size_t step, size_t pos)
{
return last + pos * step;
}
static inline size_t value(size_t last, size_t max, size_t pos)
{
return last * max + pos;
}
};
template <>
struct PosForward<ForType::HIDDEN>
{
static inline size_t valuex(size_t last, size_t step, size_t pos)
{
return last;
}
static inline size_t value(size_t last, size_t max, size_t pos)
{
return last;
}
};
template <class IndexClass, class Expr>
class SubExpr : public ExpressionBase
{
private:
SubExpr() = default;
const IndexClass* mIndPtr;
PtrId mSIPtr;
size_t mSPos;
size_t mMax;
Expr mExpr;
typedef decltype(mkExt(0).extend(mExpr.rootSteps())) ExtType;
ExtType mExt;
const Vector<SizeT>* mSubSet;
mutable ExtType mRootSteps;
public:
typedef ExpressionBase EB;
static constexpr size_t LAYER = Expr::LAYER + 1;
static constexpr size_t SIZE = Expr::SIZE + 1;
//static constexpr size_t NHLAYER = Expr::NHLAYER + 1;
DEFAULT_MEMBERS_X(SubExpr);
SubExpr(const Sptr<IndexClass>& indPtr,
std::intptr_t siptr,
const vector<size_t>* subset, Expr expr);
SubExpr(const IndexClass* indPtr, std::intptr_t siptr,
const vector<size_t>* subset, Expr expr);
inline void operator()(size_t mlast, DExt last) override final;
inline void operator()(size_t mlast, ExtType last) ;
inline void operator()(size_t mlast = 0) override final;
DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
DExt dExtension() const override final;
auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
auto extension() const -> ExtType;
};
template <ForType FT, size_t LAYER>
struct NHLayer
{
template <class Expr>
static constexpr size_t get()
{
return Expr::NHLAYER + 1;
}
};
template <size_t LAYER>
struct NHLayer<ForType::HIDDEN,LAYER>
{
template <class Expr>
static constexpr size_t get()
{
return 0;
}
};
template <>
struct NHLayer<ForType::DEFAULT,1>
{
template <class Expr>
static constexpr size_t get()
{
return Expr::LAYER;
}
};
template <class IndexClass, class Expr, ForType FT, size_t DIV>
class For : public ExpressionBase
{
private:
For() = default;
typedef typename IndexClass::RangeType RangeType;
const IndexClass* mIndPtr;
size_t mSPos;
size_t mMax;
size_t mStep;
Expr mExpr;
typedef decltype(mExpr.rootSteps()) ExtType;
ExtType mExt;
mutable ExtType mRootSteps;
public:
typedef ExpressionBase EB;
static constexpr size_t LAYER = Expr::LAYER + 1;
static constexpr size_t SIZE = Expr::SIZE;
//static constexpr size_t MAX = RangeType::SIZE / DIV;
//static constexpr size_t NHLAYER = (FT == ForType::HIDDEN) ? 0 : Expr::NHLAYER + 1;
DEFAULT_MEMBERS(For);
For(const Sptr<IndexClass>& indPtr,
size_t step, Expr expr);
For(const IndexClass* indPtr,
size_t step, Expr expr);
inline void operator()(size_t mlast, DExt last) override final;
inline void operator()(size_t mlast, ExtType last) ;
inline void operator()(size_t mlast = 0) override final;
PFor<IndexClass,Expr> parallel() const;
DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
DExt dExtension() const override final;
auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
auto extension() const -> ExtType;
};
class DynamicExpression : public ExpressionBase
{
private:
size_t mThreadId = 0;
Sptr<ExpressionBase> mNext;
DynamicExpression() : mThreadId(omp_get_thread_num()) {}
public:
static constexpr size_t LAYER = 0;
static constexpr size_t SIZE = 0;
static constexpr size_t NHLAYER = 0;
DynamicExpression(const DynamicExpression& in) :
mThreadId(omp_get_thread_num()),
mNext( (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
in.mNext : in.mNext->deepCopy()) {}
DynamicExpression(DynamicExpression&& in) :
mThreadId(omp_get_thread_num()),
mNext( (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
in.mNext : in.mNext->deepCopy()) {}
DynamicExpression& operator=(const DynamicExpression& in)
{
mThreadId = omp_get_thread_num();
mNext = (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
in.mNext : in.mNext->deepCopy();
return *this;
}
DynamicExpression& operator=(DynamicExpression&& in)
{
mThreadId = omp_get_thread_num();
mNext = (static_cast<int>(in.mThreadId) == omp_get_thread_num()) ?
in.mNext : in.mNext->deepCopy();
return *this;
}
DynamicExpression(const Sptr<ExpressionBase>& next) :
mNext(next)
{}
template <class Expr>
DynamicExpression(const ExpressionBase& next) :
mNext(std::make_shared<Expr>(next))
{}
template <class Expr>
DynamicExpression(Expr ex) : mNext( std::make_shared<Expr>(ex) ) {}
virtual Sptr<ExpressionBase> deepCopy() const override final
{
return std::make_shared<DynamicExpression>(*this);
}
inline void operator()(size_t mlast, DExt last) override final;
inline void operator()(size_t mlast, DExtT last) { (*this)(mlast,last.get()); }
inline void operator()(size_t mlast = 0) override final;
inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
inline DExt dExtension() const override final;
inline DExtT rootSteps(std::intptr_t iPtrNum = 0) const { return DExtT(dRootSteps(iPtrNum)); }
inline DExtT extension() const { return DExtT(dExtension()); }
};
*/
}
/* ========================= *
* --- TEMPLATE CODE --- *
* ========================= */
namespace CNORXZ
{
/*****************
* F o r *
*****************/
/*
template <class IndexClass, class Expr, ForType FT, size_t DIV>
For<IndexClass,Expr,FT,DIV>::For(const Sptr<IndexClass>& indPtr,
size_t step, Expr expr) :
mIndPtr(indPtr.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
{
assert(mMax % DIV == 0);
assert(mIndPtr != nullptr);
}
template <class IndexClass, class Expr, ForType FT, size_t DIV>
For<IndexClass,Expr,FT,DIV>::For(const IndexClass* indPtr,
size_t step, Expr expr) :
mIndPtr(indPtr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
{
//VCHECK(mMax);
//VCHECK(DIV);
//assert(mMax % DIV == 0);
assert(mIndPtr != nullptr);
}
template <class IndexClass, class Expr, ForType FT, size_t DIV>
inline void For<IndexClass,Expr,FT,DIV>::operator()(size_t mlast, DExt last)
{
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, size_t DIV>
inline void For<IndexClass,Expr,FT,DIV>::operator()(size_t mlast,
ExtType last)
{
typedef typename IndexClass::RangeType RangeType;
for(size_t pos = 0u; pos != ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax); ++pos){
const size_t mnpos = PosForward<FT>::valuex(mlast, mStep, pos);
const ExtType npos = last + mExt*pos;
mExpr(mnpos, npos);
}
}
template <class IndexClass, class Expr, ForType FT, size_t DIV>
inline void For<IndexClass,Expr,FT,DIV>::operator()(size_t mlast)
{
typedef typename IndexClass::RangeType RangeType;
ExtType last = rootSteps();
last.zero();
for(size_t pos = 0u; pos != ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax); ++pos){
const size_t mnpos = PosForward<FT>::valuex(mlast, mStep, pos);
const ExtType npos = last + mExt*pos;
mExpr(mnpos, npos);
}
}
template <class IndexClass, class Expr, ForType FT, size_t DIV>
auto For<IndexClass,Expr,FT,DIV>::rootSteps(std::intptr_t iPtrNum) const
-> ExtType
{
return mExpr.rootSteps(iPtrNum);
}
template <class IndexClass, class Expr, ForType FT, size_t DIV>
auto For<IndexClass,Expr,FT,DIV>::extension() const
-> ExtType
{
return mExt;
}
template <class IndexClass, class Expr, ForType FT, size_t DIV>
DExt For<IndexClass,Expr,FT,DIV>::dRootSteps(std::intptr_t iPtrNum) const
{
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, size_t DIV>
DExt For<IndexClass,Expr,FT,DIV>::dExtension() const
{
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, size_t DIV>
PFor<IndexClass,Expr,DIV> For<IndexClass,Expr,FT,DIV>::parallel() const
{
static_assert(FT == ForType::DEFAULT, "hidden for not parallelizable");
return PFor<IndexClass,Expr,DIV>(mIndPtr, mStep, mExpr);
}
*/
/******************
* P F o r *
******************/
/*
template <class IndexClass, class Expr, size_t DIV>
PFor<IndexClass,Expr,DIV>::PFor(const Sptr<IndexClass>& indPtr,
size_t step, Expr expr) :
mIndPtr(indPtr.get()), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
{
//assert(mMax % DIV == 0);
assert(mIndPtr != nullptr);
}
template <class IndexClass, class Expr, size_t DIV>
PFor<IndexClass,Expr,DIV>::PFor(const IndexClass* indPtr,
size_t step, Expr expr) :
mIndPtr(indPtr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()), mStep(step),
mExpr(expr), mExt(mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )))
{
assert(mMax % DIV == 0);
assert(mIndPtr != nullptr);
}
template <class IndexClass, class Expr, size_t DIV>
inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast, DExt last)
{
operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
//operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
}
template <class IndexClass, class Expr, size_t DIV>
inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast,
ExtType last)
{
CHECK;
typedef typename IndexClass::RangeType RangeType;
int pos = 0;
size_t mnpos = 0;
ExtType npos;
#pragma omp parallel shared(mExpr) private(pos,mnpos,npos)
{
auto expr = mExpr;
#pragma omp for nowait
for(pos = 0; pos < static_cast<int>(ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax)); pos++){
mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
npos = last + mExt*static_cast<size_t>(pos);
expr(mnpos, npos);
}
}
}
template <class IndexClass, class Expr, size_t DIV>
inline void PFor<IndexClass,Expr,DIV>::operator()(size_t mlast)
{
CHECK;
ExtType last = rootSteps();
last.zero();
int pos = 0;
size_t mnpos = 0;
ExtType npos = rootSteps();
npos.zero();
#pragma omp parallel shared(mExpr) private(pos,mnpos,npos)
{
auto expr = mExpr;
#pragma omp for nowait
for(pos = 0; pos < static_cast<int>(ForBound<RangeType::ISSTATIC>::template bound<RangeType::SIZE,DIV>(mMax)); pos++){
mnpos = PosForward<ForType::DEFAULT>::valuex(mlast, mStep, pos);
npos = last + mExt*static_cast<size_t>(pos);
expr(mnpos, npos);
}
}
}
template <class IndexClass, class Expr, size_t DIV>
auto PFor<IndexClass,Expr,DIV>::rootSteps(std::intptr_t iPtrNum) const
-> ExtType
{
return mExpr.rootSteps(iPtrNum);
}
template <class IndexClass, class Expr, size_t DIV>
auto PFor<IndexClass,Expr,DIV>::extension() const
-> ExtType
{
return mExt;
}
template <class IndexClass, class Expr, size_t DIV>
DExt PFor<IndexClass,Expr,DIV>::dRootSteps(std::intptr_t iPtrNum) const
{
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, size_t DIV>
DExt PFor<IndexClass,Expr,DIV>::dExtension() const
{
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));
}
*/
/****************
* SubExpr *
****************/
/*
template <class IndexClass, class Expr>
SubExpr<IndexClass,Expr>::SubExpr(const Sptr<IndexClass>& indPtr,
std::intptr_t siptr,
const vector<size_t>* subset, Expr expr) :
mIndPtr(indPtr.get()), mSIPtr(siptr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
mExpr(expr),
mExt( mkExt(0).extend( mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )) ) ),
mSubSet(subset)
{
assert(mIndPtr != nullptr);
}
template <class IndexClass, class Expr>
SubExpr<IndexClass,Expr>::SubExpr(const IndexClass* indPtr, std::intptr_t siptr,
const vector<size_t>* subset, Expr expr) :
mIndPtr(indPtr), mSIPtr(siptr), mSPos(mIndPtr->pos()), mMax(mIndPtr->max()),
mExpr(expr),
mExt( mkExt(0).extend( mExpr.rootSteps( reinterpret_cast<std::intptr_t>( mIndPtr )) ) ),
mSubSet(subset)
{
assert(mIndPtr != nullptr);
}
template <class IndexClass, class Expr>
inline void SubExpr<IndexClass,Expr>::operator()(size_t mlast, DExt last)
{
operator()(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
//operator()(mlast, *reinterpret_cast<ExtType const*>(last.first));
}
template <class IndexClass, class Expr>
inline void SubExpr<IndexClass,Expr>::operator()(size_t mlast,
ExtType last)
{
const size_t pos = (*mSubSet)[last.val()];
const size_t mnpos = mlast;
const ExtType npos = last + mExt*pos;
mExpr(mnpos, getX<1>( npos ));
}
template <class IndexClass, class Expr>
inline void SubExpr<IndexClass,Expr>::operator()(size_t mlast)
{
ExtType last = rootSteps();
last.zero();
const size_t pos = (*mSubSet)[last.val()];
const size_t mnpos = mlast;
const ExtType npos = last + mExt*pos;
mExpr(mnpos, getX<1>( npos ));
}
template <class IndexClass, class Expr>
auto SubExpr<IndexClass,Expr>::rootSteps(std::intptr_t iPtrNum) const
-> ExtType
{
return mkExt(iPtrNum == mSIPtr ? 1 : 0).extend(mExpr.rootSteps(iPtrNum));
}
template <class IndexClass, class Expr>
auto SubExpr<IndexClass,Expr>::extension() const
-> ExtType
{
return mExt;
}
template <class IndexClass, class Expr>
DExt SubExpr<IndexClass,Expr>::dRootSteps(std::intptr_t iPtrNum) const
{
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_shared<ExtT<ExtType>>(mExt);
//return std::make_pair<size_t const*,size_t>(reinterpret_cast<size_t const*>(&mExt),
// sizeof(ExtType)/sizeof(size_t));
}
*/
/***************************
* DynamicExpression *
***************************/
/*
inline void DynamicExpression::operator()(size_t mlast, DExt last)
{
(*mNext)(mlast,last);
}
inline void DynamicExpression::operator()(size_t mlast)
{
(*mNext)(mlast);
}
inline DExt DynamicExpression::dRootSteps(std::intptr_t iPtrNum) const
{
return mNext->dRootSteps(iPtrNum);
}
inline DExt DynamicExpression::dExtension() const
{
return mNext->dExtension();
}
*/
} // namespace CNORXZInternal
#endif

View file

@ -1,148 +0,0 @@
#include "ranges/rheader.h"
#include "ranges/x_to_string.h"
#include "ranges/ranges_header.cc.h"
namespace CNORXZ
{
std::shared_ptr<NullRF> mkNUL(const char* dp, size_t size)
{
return std::make_shared<NullRF>();
}
/********************
* GenSingleRange *
********************/
std::shared_ptr<GenSingleRange<size_t,SpaceType::NUL,0>>
GenSingleRangeFactory<size_t,SpaceType::NUL,0>::mRInstance = nullptr;
std::shared_ptr<NullRange> nullr()
{
static NullRF nrf; // just that mRInstance is initialized
static auto nr = std::dynamic_pointer_cast<NullRange>( nrf.create() );
return NullRF::mRInstance;
}
std::shared_ptr<NullIndex> nulli()
{
return std::make_shared<NullIndex>(nullr());
}
GenSingleRangeFactory<size_t,SpaceType::NUL,0>::GenSingleRangeFactory()
{
// Singleton
if(not mRInstance){
if(not mProd){
mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::NUL,0>() );
setSelf();
}
mRInstance = std::dynamic_pointer_cast<NullRange>( mProd );
} else {
mProd = mRInstance;
}
}
std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::NUL,0>::create()
{
return mProd;
}
/********************
* GenSingleRange *
********************/
size_t GenSingleRange<size_t,SpaceType::NUL,0>::get(size_t pos) const
{
return 0;
}
size_t GenSingleRange<size_t,SpaceType::NUL,0>::getMeta(size_t metapos) const
{
return 0;
}
size_t GenSingleRange<size_t,SpaceType::NUL,0>::size() const
{
return 1;
}
size_t GenSingleRange<size_t,SpaceType::NUL,0>::dim() const
{
return 1;
}
SpaceType GenSingleRange<size_t,SpaceType::NUL,0>::spaceType() const
{
return SpaceType::NUL;
}
vector<size_t> GenSingleRange<size_t,SpaceType::NUL,0>::typeNum() const
{
return {NumTypeMap<size_t>::num()};
}
size_t GenSingleRange<size_t,SpaceType::NUL,0>::cmeta(char* target, size_t pos) const
{
*reinterpret_cast<size_t*>(target) = 0;
return sizeof(size_t);
}
size_t GenSingleRange<size_t,SpaceType::NUL,0>::cmetaSize() const
{
return sizeof(size_t);
}
std::string GenSingleRange<size_t,SpaceType::NUL,0>::stringMeta(size_t pos) const
{
return std::to_string(get(pos));
}
vector<char> GenSingleRange<size_t,SpaceType::NUL,0>::data() const
{
DataHeader h = dataHeader();
vector<char> out;
out.reserve(h.metaSize + sizeof(DataHeader));
char* hcp = reinterpret_cast<char*>(&h);
out.insert(out.end(), hcp, hcp + sizeof(DataHeader));
return out;
}
DataHeader GenSingleRange<size_t,SpaceType::NUL,0>::dataHeader() const
{
DataHeader h;
h.spaceType = static_cast<int>( SpaceType::NUL );
h.metaSize = 0;
h.multiple = 0;
return h;
}
typename GenSingleRange<size_t,SpaceType::NUL,0>::IndexType GenSingleRange<size_t,SpaceType::NUL,0>::begin() const
{
GenSingleIndex<size_t,SpaceType::NUL,0> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
i = 0;
return i;
}
typename GenSingleRange<size_t,SpaceType::NUL,0>::IndexType GenSingleRange<size_t,SpaceType::NUL,0>::end() const
{
GenSingleIndex<size_t,SpaceType::NUL,0> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) );
i = size();
return i;
}
// put this in the interface class !!!
/*
std::shared_ptr<VIWB> GenSingleRange<size_t,SpaceType::NUL,0>::index() const
{
typedef IndexWrapper<IndexType> IW;
return std::make_shared<IW>
( std::make_shared<IndexType>
( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
( std::shared_ptr<RangeBase>( RB::mThis ) ) ) );
}
*/
}

View file

@ -6,6 +6,7 @@
#include "ranges/ranges.h"
#include "operation/operation.h"
#include "array/array.h"
#include "test_numbers.h"
namespace

View file

@ -6,6 +6,7 @@
//#include "cnorxz.h"
#include "ranges/ranges.h"
#include "array/array.h"
namespace
{