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

aindex: inherit yindex + yrange: specialize RangeCast + corrections in DArray classes + more DArray tests

Browse source
This commit is contained in:
Christian Zimmermann 2022-11-22 19:11:41 +01:00
parent a3d3d99c8d
commit 216bb3f56e
10 changed files with 115 additions and 242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

181
src/include/array/aindex.cc.h
View file

@ -9,206 +9,83 @@ namespace CNORXZ
{
template <typename T>
AIndex<T>::AIndex(const T* data, const RangePtr& range, SizeT pos):
IndexInterface<AIndex<T>,DType>(pos),
mRangePtr(rangeCast<YRange>(range)), mIs(mRangePtr->dim()),
mBlockSizes(mRangePtr->dim()), mExternalControl(false),
AIndex<T>::AIndex(const T* data, const RangePtr& range, SizeT lexpos) :
YIndex(range, lexpos),
mCData(data)
{
assert(0);
// init ...!!!
}
{}
template <typename T>
AIndex<T>& AIndex<T>::operator=(SizeT pos)
{
IB::mPos = pos;
assert(0);
// sub inds... (LAZY!!!) !!!
return *this;
}
template <typename T>
AIndex<T>& AIndex<T>::operator++()
{
if(mExternalControl) this->sync();
assert(0);
// increment sub inds (LAZY!!!) !!!
++IB::mPos;
return *this;
}
template <typename T>
AIndex<T>& AIndex<T>::operator--()
{
if(mExternalControl) this->sync();
assert(0);
// decrement sub inds (LAZY!!!) !!!
--IB::mPos;
return *this;
}
AIndex<T>::AIndex(const T* data, const YIndex& yindex) :
YIndex(yindex),
mCData(data)
{}
template <typename T>
AIndex<T> AIndex<T>::operator+(Int n) const
{
assert(0);
// sub inds !!!
return AIndex<T>(mCData, mRangePtr, IB::mPos + n);
AIndex<T> o = *this;
o += n;
return o;
}
template <typename T>
AIndex<T> AIndex<T>::operator-(Int n) const
{
assert(0);
// sub inds !!!
return AIndex<T>(mCData, mRangePtr, IB::mPos - n);
}
template <typename T>
AIndex<T>& AIndex<T>::operator+=(Int n)
{
assert(0);
// sub inds !!!
IB::mPos += n;
return *this;
}
template <typename T>
AIndex<T>& AIndex<T>::operator-=(Int n)
{
assert(0);
// sub inds !!!
IB::mPos -= n;
return *this;
AIndex<T> o = *this;
o -= n;
return o;
}
template <typename T>
const T& AIndex<T>::operator*() const
{
assert(0);
// sub inds !!!
return mCData[IB::mPos];
}
template <typename T>
const T* AIndex<T>::operator->() const
{
assert(0);
// sub inds !!!
return mCData + IB::mPos;
}
template <typename T>
int AIndex<T>::pp(PtrId idxPtrNum)
{
assert(0);
// sub inds !!!
return 0;
}
BIndex<T>::BIndex(T* data, const RangePtr& range, SizeT lexpos) :
AIndex<T>(data, range, lexpos),
mData(data)
{}
template <typename T>
int AIndex<T>::mm(PtrId idxPtrNum)
{
assert(0);
// sub inds !!!
return 0;
}
template <typename T>
SizeT AIndex<T>::dim() const
{
return mIs.size();
}
template <typename T>
RangePtr AIndex<T>::range() const
{
return mRangePtr;
}
template <typename T>
SizeT AIndex<T>::getStepSize(SizeT n) const
{
assert(0);
// sub inds !!!
return 0;
}
template <typename T>
String AIndex<T>::stringMeta() const
{
String out = "[";
auto it = mIs.begin();
for(; it != mIs.end()-1; ++it){
out += (*it)->stringMeta() + ",";
}
out += (*it)->stringMeta() + "]";
return out;
}
template <typename T>
DType AIndex<T>::meta() const
{
//this->sync();
Vector<DType> v(mIs.size());
std::transform(mIs.begin(), mIs.end(), v.begin(), [](auto& x) { return x->meta(); });
return DType(v);
}
template <typename T>
AIndex<T>& AIndex<T>::at(const DType& meta)
{
auto& v = std::any_cast<const Vector<DType>&>(meta.get());
assert(v.size() == mIs.size());
for(SizeT i = 0; i != mIs.size(); ++i){
mIs[i]->at(v[i]);
}
return *this;
}
/*
template <typename T>
DExpr AIndex<T>::ifor(SizeT step, DExpr ex) const
{
return mI->ifor(step, ex);
}
template <typename T>
DExpr AIndex<T>::iforh(SizeT step, DExpr ex) const
{
return mI->iforh(step, ex);
}
*/
template <typename T>
BIndex<T>::BIndex(T* data, const RangePtr& range, SizeT pos) :
AIndex<T>(data, range, pos), mData(data) {}
template <typename T>
BIndex<T>::BIndex(T* data, const AIndex<T>& ai, SizeT pos) :
AIndex<T>(data, ai.range(), pos), mData(data) {}
BIndex<T>::BIndex(T* data, const AIndex<T>& ai) :
AIndex<T>(data, ai.range(), ai.lex()),
mData(data)
{}
template <typename T>
BIndex<T> BIndex<T>::operator+(Int n) const
{
return BIndex<T>(mData, IB::mRangePtr, IB::mPos + n);
BIndex<T> o = *this;
o += n;
return o;
}
template <typename T>
BIndex<T> BIndex<T>::operator-(Int n) const
{
return BIndex<T>(mData, IB::mRangePtr, IB::mPos - n);
BIndex<T> o = *this;
o -= n;
return o;
}
template <typename T>
T& BIndex<T>::operator*()
{
return mData[AI::mPos];
return mData[IB::mPos];
}
template <typename T>
T* BIndex<T>::operator->()
{
return mData+AI::mPos;
return mData + IB::mPos;
}
}

40
src/include/array/aindex.h
View file

@ -10,51 +10,25 @@
namespace CNORXZ
{
// rename: AIndex (A = Array)
// implementation similar to YIndex
// AIndex (A = Array)
template <typename T>
class AIndex : public IndexInterface<AIndex<T>,DType>
class AIndex : public YIndex
{
public:
typedef IndexInterface<AIndex<T>,DType> IB;
typedef YIndex::IB IB;
using YIndex::operator=;
DEFAULT_MEMBERS(AIndex);
AIndex(const T* data, const RangePtr& range, SizeT pos = 0);
AIndex(const T* data, const RangePtr& range, SizeT lexpos = 0);
AIndex(const T* data, const YIndex& yindex);
AIndex& sync(); // recalculate 'IB::mPos' when externalControl == true
AIndex& operator()(const Vector<XIndexPtr>& inds); // control via external indice
AIndex& operator()(); // -> sync; just to shorten the code
AIndex& operator=(SizeT pos);
AIndex& operator++();
AIndex& operator--();
AIndex operator+(Int n) const;
AIndex operator-(Int n) const;
AIndex& operator+=(Int n);
AIndex& operator-=(Int n);
const T& operator*() const;
const T* operator->() const;
Int pp(PtrId idxPtrNum);
Int mm(PtrId idxPtrNum);
SizeT dim() const;
RangePtr range() const;
SizeT getStepSize(SizeT n) const;
String stringMeta() const;
DType meta() const;
AIndex& at(const DType& meta);
//DExpr ifor(SizeT step, DExpr ex) const;
//DExpr iforh(SizeT step, DExpr ex) const;
protected:
Sptr<YRange> mRangePtr;
Vector<XIndexPtr> mIs;
Vector<SizeT> mBlockSizes; // dim() elements only!!!
bool mExternalControl = false;
const T* mCData = nullptr;
};
@ -69,7 +43,7 @@ namespace CNORXZ
DEFAULT_MEMBERS(BIndex);
BIndex(T* data, const RangePtr& range, SizeT pos = 0);
BIndex(T* data, const AIndex<T>& cci, SizeT pos = 0);
BIndex(T* data, const AIndex<T>& cci);
BIndex operator+(Int n) const;
BIndex operator-(Int n) const;

22
src/include/array/darray.cc.h
View file

@ -11,15 +11,25 @@ namespace CNORXZ
***************/
template <typename T>
DArray<T>::DArray(const RangePtr& range) : MDArrayBase<T>(range), mCont(range->size()) {}
DArray<T>::DArray(const RangePtr& range) :
MDArrayBase<T>(range), mCont(range->size())
{}
template <typename T>
DArray<T>::DArray(const RangePtr& range, const Vector<T>& vec) :
MDArrayBase<T>(range), mCont(vec) {}
MDArrayBase<T>(range), mCont(vec)
{}
template <typename T>
DArray<T>::DArray(const RangePtr& range, Vector<T>&& vec) :
MDArrayBase<T>(range), mCont(vec) {}
MDArrayBase<T>(range), mCont(vec)
{}
template <typename T>
SizeT DArray<T>::pmax() const
{
return mCont.size();
}
template <typename T>
const T* DArray<T>::data() const
@ -36,15 +46,13 @@ namespace CNORXZ
template <typename T>
typename DArray<T>::const_iterator DArray<T>::cbegin() const
{
assert(0);
return const_iterator();
return const_iterator(mCont.data(), AB::mRange);
}
template <typename T>
typename DArray<T>::const_iterator DArray<T>::cend() const
{
assert(0);
return const_iterator();
return const_iterator(mCont.data(), AB::mRange, mCont.size());
}
template <typename T>

9
src/include/array/darray.h
View file

@ -11,29 +11,26 @@ namespace CNORXZ
class DArray : public MDArrayBase<T>
{
public:
typedef DArrayBase<T> AB;
typedef typename AB::const_iterator const_iterator;
using DArrayBase<T>::operator[];
using MDArrayBase<T>::operator[];
private:
Vector<T> mCont;
public:
DEFAULT_MEMBERS(DArray);
DArray(const RangePtr& range);
DArray(const RangePtr& range, const Vector<T>& vec);
DArray(const RangePtr& range, Vector<T>&& vec);
virtual SizeT pmax() const override;
virtual const T* data() const override;
virtual T* data() override;
virtual const_iterator cbegin() const override;
virtual const_iterator cend() const override;
virtual bool isView() const override;
private:
Vector<T> mCont;
};
}

37
src/include/array/darray_base.cc.h
View file

@ -6,25 +6,31 @@
namespace CNORXZ
{
/****************
/******************
* DArrayBase *
***************/
******************/
template <typename T>
DArrayBase<T>::DArrayBase(const RangePtr& range) : mRange(range), mInit(true) {}
DArrayBase<T>::DArrayBase(const RangePtr& range) :
mRange(rangeCast<YRange>(range))
{}
template <typename T>
template <typename I, typename M>
const T& DArrayBase<T>::operator[](const IndexInterface<I,M>& i) const
{
return *(this->begin()+i);
auto ai = this->begin() + i.lex();
return *ai;
}
template <typename T>
template <typename I, typename M>
const T& DArrayBase<T>::at(const IndexInterface<I,M>& i) const
{
return *this->begin().plus(i);
CXZ_ASSERT(i.lex() < this->size(), "index out of range");
// check further compatibility of index/range format!!!
auto ai = this->begin() + i.lex();
return *ai;
}
template <typename T>
@ -51,11 +57,6 @@ namespace CNORXZ
return this->cend();
}
template <typename T>
bool DArrayBase<T>::isInit() const
{
return mInit;
}
/*
template <typename T>
template <typename I, typename M>
@ -65,25 +66,31 @@ namespace CNORXZ
}
*/
/*****************
/*******************
* MDArrayBase *
****************/
*******************/
template <typename T>
MDArrayBase<T>::MDArrayBase(const RangePtr& range) : DArrayBase<T>(range) {}
MDArrayBase<T>::MDArrayBase(const RangePtr& range) :
DArrayBase<T>(range)
{}
template <typename T>
template <typename I, typename M>
T& MDArrayBase<T>::operator[](const IndexInterface<I,M>& i)
{
return *(this->begin()+i);
auto ai = this->begin() + i.lex();
return *ai;
}
template <typename T>
template <typename I, typename M>
T& MDArrayBase<T>::at(const IndexInterface<I,M>& i)
{
return *this->begin().plus(i);
CXZ_ASSERT(i.pos() < this->pmax(), "index out of range");
// check further compatibility of index/range format!!!
auto ai = this->begin() + i.lex();
return *ai;
}
template <typename T>

3
src/include/array/darray_base.h
View file

@ -21,7 +21,6 @@ namespace CNORXZ
protected:
RangePtr mRange;
bool mInit = false;
public:
@ -40,6 +39,7 @@ namespace CNORXZ
Sptr<DArrayBase<T>> sl(const IndexInterface<I,M>& i) const;
virtual const T* data() const = 0;
virtual SizeT pmax() const = 0; // max allocated postion of data() (exclusive!)
virtual SizeT size() const;
virtual RangePtr range() const;
@ -49,7 +49,6 @@ namespace CNORXZ
virtual const_iterator cend() const = 0;
virtual bool isView() const = 0;
virtual bool isInit() const;
//template <typename I, typename M>
//ConstOperationRoot<T,I> operator()(const IndexPtr<I,M>& i) const;

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

@ -113,6 +113,12 @@ namespace CNORXZ
Vector<RangePtr> mRVec;
};
template <>
struct RangeCast<YRange>
{
static Sptr<YRange> func(const RangePtr& r);
};
}
#endif

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

@ -375,4 +375,12 @@ namespace CNORXZ
YRange::YRange(Vector<RangePtr>&& rvec) : mRVec(std::forward<Vector<RangePtr>>(rvec)) {}
/*******************
* Range Casts *
*******************/
Sptr<YRange> RangeCast<YRange>::func(const RangePtr& r)
{
return std::dynamic_pointer_cast<YRange>( YRangeFactory({r}).create() );
}
}

36
src/tests/darray_unit_test.cc
View file

@ -6,9 +6,10 @@
#include "gtest/gtest.h"
#include "cnorxz.h"
#include "test_numbers.h"
namespace {
namespace
{
using namespace CNORXZ;
class DA_1D_Test : public ::testing::Test
@ -27,29 +28,20 @@ namespace {
TEST_F(DA_1D_Test, Basics)
{
DArray<double> a(mCR1);
DArray<Double> a(mCR1, ::CNORXZ::Test::Numbers::get(0,mSize));
auto crx = std::dynamic_pointer_cast<CRange>(mCR1);
EXPECT_EQ(a.size(), mSize);
auto ei = crx->end();
EXPECT_EQ(ei.lex(), mSize);
for(auto i = crx->begin(); i != ei; ++i){
EXPECT_EQ(i.lex(), i.pos());
EXPECT_EQ(a[i], a.data()[i.lex()]);
EXPECT_EQ(a.at(i), a.data()[i.lex()]);
}
/*
TEST_F(DA_1D_Test, ReFormat)
{
swapFactory<SRF>( rfbptr, { 'a', 'c', 'e', 'g', 'i' } );
std::shared_ptr<SRange> sr2 = std::dynamic_pointer_cast<SRange>( rfbptr->create() );
Array<double,DA_1D_Test::SRange> ma(srptr, vv);
auto i = ma.cbegin();
EXPECT_EQ( ma[ i.at('x') ], 3.141);
auto ma2 = ma.format( sr2 );
auto j = ma2.cbegin();
EXPECT_EQ( ma[ j.at('a') ], 3.141);
EXPECT_EQ( ma[ j.at('c') ], 2.718);
EXPECT_EQ( ma[ j.at('e') ], 1.618);
EXPECT_EQ( ma[ j.at('g') ], 0.693);
EXPECT_EQ( ma[ j.at('i') ], 0.577);
EXPECT_THROW({a.at(ei);}, std::runtime_error);
}
*/
} // end namespace
int main(int argc, char** argv)

5
src/tests/test_numbers.h
View file

@ -1,4 +1,7 @@
#ifndef __test_numbers_h__
#define __test_numbers_h__
#include <fstream>
//#include "base/types.h"
//#include "base/assert.h"
@ -50,3 +53,5 @@ namespace CNORXZ
};
}
}
#endif