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

rename darray_base -> carray_base, mdarray_base -> array_base, darray -> marray + rename corresponding files/tests

Browse source
This commit is contained in:
Christian Zimmermann 2022-12-06 14:48:44 +01:00
parent 9aba24cf01
commit 9938d43f9c
11 changed files with 141 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/include/array/array.cc.h
View file

@ -1,6 +1,6 @@
//#include "access.cc.h"
#include "darray_base.cc.h"
#include "darray.cc.h"
#include "array_base.cc.h"
#include "marray.cc.h"
#include "aindex.cc.h"
//#include "functional_array.cc.h"

4
src/include/array/array.h
View file

@ -1,7 +1,7 @@
//#include "access.h"
#include "darray_base.h"
#include "darray.h"
#include "array_base.h"
#include "marray.h"
#include "aindex.h"
//#include "functional_array.h"

44
src/include/array/darray_base.cc.h → src/include/array/array_base.cc.h
View file

@ -1,23 +1,23 @@
#ifndef __cxz_darray_base_cc_h__
#define __cxz_darray_base_cc_h__
#ifndef __cxz_array_base_cc_h__
#define __cxz_array_base_cc_h__
#include "darray_base.h"
#include "array_base.h"
namespace CNORXZ
{
/******************
* DArrayBase *
* CArrayBase *
******************/
template <typename T>
DArrayBase<T>::DArrayBase(const RangePtr& range) :
CArrayBase<T>::CArrayBase(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
const T& CArrayBase<T>::operator[](const IndexInterface<I,M>& i) const
{
auto ai = this->begin() + i.lex();
return *ai;
@ -25,7 +25,7 @@ namespace CNORXZ
template <typename T>
template <typename I, typename M>
const T& DArrayBase<T>::at(const IndexInterface<I,M>& i) const
const T& CArrayBase<T>::at(const IndexInterface<I,M>& i) const
{
CXZ_ASSERT(i.lex() < this->size(), "index out of range");
// check further compatibility of index/range format!!!
@ -34,25 +34,25 @@ namespace CNORXZ
}
template <typename T>
SizeT DArrayBase<T>::size() const
SizeT CArrayBase<T>::size() const
{
return mRange->size();
}
template <typename T>
RangePtr DArrayBase<T>::range() const
RangePtr CArrayBase<T>::range() const
{
return mRange;
}
template <typename T>
typename DArrayBase<T>::const_iterator DArrayBase<T>::begin() const
typename CArrayBase<T>::const_iterator CArrayBase<T>::begin() const
{
return this->cbegin();
}
template <typename T>
typename DArrayBase<T>::const_iterator DArrayBase<T>::end() const
typename CArrayBase<T>::const_iterator CArrayBase<T>::end() const
{
return this->cend();
}
@ -60,24 +60,24 @@ namespace CNORXZ
/*
template <typename T>
template <typename I, typename M>
ConstOperationRoot<T,I> DArrayBase<T>::operator()(const IndexPtr<I,M>& i) const
ConstOperationRoot<T,I> CArrayBase<T>::operator()(const IndexPtr<I,M>& i) const
{
return ConstOperationRoot<T,I>();
}
*/
/*******************
* MDArrayBase *
*******************/
/*****************
* ArrayBase *
*****************/
template <typename T>
MDArrayBase<T>::MDArrayBase(const RangePtr& range) :
DArrayBase<T>(range)
ArrayBase<T>::ArrayBase(const RangePtr& range) :
CArrayBase<T>(range)
{}
template <typename T>
template <typename I, typename M>
T& MDArrayBase<T>::operator[](const IndexInterface<I,M>& i)
T& ArrayBase<T>::operator[](const IndexInterface<I,M>& i)
{
auto ai = this->begin() + i.lex();
return *ai;
@ -85,7 +85,7 @@ namespace CNORXZ
template <typename T>
template <typename I, typename M>
T& MDArrayBase<T>::at(const IndexInterface<I,M>& i)
T& ArrayBase<T>::at(const IndexInterface<I,M>& i)
{
CXZ_ASSERT(i.pos() < this->pmax(), "index out of range");
// check further compatibility of index/range format!!!
@ -94,13 +94,13 @@ namespace CNORXZ
}
template <typename T>
typename MDArrayBase<T>::iterator MDArrayBase<T>::begin()
typename ArrayBase<T>::iterator ArrayBase<T>::begin()
{
return iterator(this->data(), this->cbegin());
}
template <typename T>
typename MDArrayBase<T>::iterator MDArrayBase<T>::end()
typename ArrayBase<T>::iterator ArrayBase<T>::end()
{
return iterator(this->data(), this->cend());
}
@ -108,7 +108,7 @@ namespace CNORXZ
/*
template <typename T>
template <typename I, typename M>
OperationRoot<T,I> MDArrayBase<T>::operator()(const IndexPtr<I,M>& i)
OperationRoot<T,I> ArrayBase<T>::operator()(const IndexPtr<I,M>& i)
{
return OperationRoot<T,I>();
}

42
src/include/array/darray_base.h → src/include/array/array_base.h
View file

@ -1,6 +1,6 @@
#ifndef __cxz_darray_base_h__
#define __cxz_darray_base_h__
#ifndef __cxz_array_base_h__
#define __cxz_array_base_h__
#include <cstdlib>
#include <vector>
@ -14,7 +14,7 @@
namespace CNORXZ
{
template <typename T>
class DArrayBase
class CArrayBase
{
public:
typedef AIndex<T> const_iterator;
@ -24,10 +24,10 @@ namespace CNORXZ
public:
DArrayBase(const RangePtr& range);
DEFAULT_MEMBERS(DArrayBase);
CArrayBase(const RangePtr& range);
DEFAULT_MEMBERS(CArrayBase);
virtual ~DArrayBase() = default;
virtual ~CArrayBase() = default;
template <typename I, typename M>
const T& operator[](const IndexInterface<I,M>& i) const;
@ -36,7 +36,7 @@ namespace CNORXZ
const T& at(const IndexInterface<I,M>& i) const;
template <typename I, typename M>
Sptr<DArrayBase<T>> sl(const IndexInterface<I,M>& i) const;
Sptr<CArrayBase<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!)
@ -55,24 +55,24 @@ namespace CNORXZ
};
template <typename T>
class MDArrayBase : public DArrayBase<T>
class ArrayBase : public CArrayBase<T>
{
public:
typedef DArrayBase<T> DAB;
typedef typename DAB::const_iterator const_iterator;
typedef CArrayBase<T> CAB;
typedef typename CAB::const_iterator const_iterator;
typedef BIndex<T> iterator;
using DAB::operator[];
using DAB::at;
using DAB::data;
using DAB::begin;
using DAB::end;
using DAB::cbegin;
using DAB::cend;
//using DAB::operator();
using CAB::operator[];
using CAB::at;
using CAB::data;
using CAB::begin;
using CAB::end;
using CAB::cbegin;
using CAB::cend;
//using CAB::operator();
MDArrayBase(const RangePtr& range);
DEFAULT_MEMBERS(MDArrayBase);
ArrayBase(const RangePtr& range);
DEFAULT_MEMBERS(ArrayBase);
template <typename I, typename M>
T& operator[](const IndexInterface<I,M>& i);
@ -81,7 +81,7 @@ namespace CNORXZ
T& at(const IndexInterface<I,M>& i);
template <typename I, typename M>
Sptr<MDArrayBase<T>> sl(const IndexInterface<I,M>& i);
Sptr<ArrayBase<T>> sl(const IndexInterface<I,M>& i);
virtual T* data() = 0;

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

@ -1,66 +0,0 @@
#ifndef __cxz_darray_cc_h__
#define __cxz_darray_cc_h__
#include "darray.h"
namespace CNORXZ
{
/****************
* DArray *
***************/
template <typename T>
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)
{}
template <typename T>
DArray<T>::DArray(const RangePtr& range, Vector<T>&& 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
{
return mCont.data();
}
template <typename T>
T* DArray<T>::data()
{
return mCont.data();
}
template <typename T>
typename DArray<T>::const_iterator DArray<T>::cbegin() const
{
return const_iterator(mCont.data(), AB::mRange);
}
template <typename T>
typename DArray<T>::const_iterator DArray<T>::cend() const
{
return const_iterator(mCont.data(), AB::mRange, mCont.size());
}
template <typename T>
bool DArray<T>::isView() const
{
return false;
}
}
#endif

66
src/include/array/marray.cc.h Normal file
View file

@ -0,0 +1,66 @@
#ifndef __cxz_marray_cc_h__
#define __cxz_marray_cc_h__
#include "marray.h"
namespace CNORXZ
{
/****************
* MArray *
***************/
template <typename T>
MArray<T>::MArray(const RangePtr& range) :
ArrayBase<T>(range), mCont(range->size())
{}
template <typename T>
MArray<T>::MArray(const RangePtr& range, const Vector<T>& vec) :
ArrayBase<T>(range), mCont(vec)
{}
template <typename T>
MArray<T>::MArray(const RangePtr& range, Vector<T>&& vec) :
ArrayBase<T>(range), mCont(vec)
{}
template <typename T>
SizeT MArray<T>::pmax() const
{
return mCont.size();
}
template <typename T>
const T* MArray<T>::data() const
{
return mCont.data();
}
template <typename T>
T* MArray<T>::data()
{
return mCont.data();
}
template <typename T>
typename MArray<T>::const_iterator MArray<T>::cbegin() const
{
return const_iterator(mCont.data(), AB::mRange);
}
template <typename T>
typename MArray<T>::const_iterator MArray<T>::cend() const
{
return const_iterator(mCont.data(), AB::mRange, mCont.size());
}
template <typename T>
bool MArray<T>::isView() const
{
return false;
}
}
#endif

22
src/include/array/darray.h → src/include/array/marray.h
View file

@ -1,26 +1,26 @@
#ifndef __cxz_darray_h__
#define __cxz_darray_h__
#ifndef __cxz_marray_h__
#define __cxz_marray_h__
#include "darray_base.h"
#include "array_base.h"
namespace CNORXZ
{
template <typename T>
class DArray : public MDArrayBase<T>
class MArray : public ArrayBase<T>
{
public:
typedef DArrayBase<T> AB;
typedef CArrayBase<T> AB;
typedef typename AB::const_iterator const_iterator;
using DArrayBase<T>::operator[];
using MDArrayBase<T>::operator[];
using CArrayBase<T>::operator[];
using ArrayBase<T>::operator[];
DEFAULT_MEMBERS(DArray);
DArray(const RangePtr& range);
DArray(const RangePtr& range, const Vector<T>& vec);
DArray(const RangePtr& range, Vector<T>&& vec);
DEFAULT_MEMBERS(MArray);
MArray(const RangePtr& range);
MArray(const RangePtr& range, const Vector<T>& vec);
MArray(const RangePtr& range, Vector<T>&& vec);
virtual SizeT pmax() const override;
virtual const T* data() const override;

4
src/include/operation/op_types.cc.h
View file

@ -61,7 +61,7 @@ namespace CNORXZ
***************/
template <typename T, class IndexT>
constexpr COpRoot<T,IndexT>::COpRoot(const DArrayBase<T>& a, const Sptr<IndexT>& ind) :
constexpr COpRoot<T,IndexT>::COpRoot(const CArrayBase<T>& a, const Sptr<IndexT>& ind) :
mData(a.data()),
mIndex(ind)
{}
@ -227,7 +227,7 @@ namespace CNORXZ
****************/
template <typename T, class IndexT>
constexpr OpRoot<T,IndexT>::OpRoot(MDArrayBase<T>& a, const Sptr<IndexT>& ind) :
constexpr OpRoot<T,IndexT>::OpRoot(ArrayBase<T>& a, const Sptr<IndexT>& ind) :
mData(a.data()),
mIndex(ind)
{}

6
src/include/operation/op_types.h
View file

@ -5,7 +5,7 @@
#include "base/base.h"
#include "xpr/xpr_base.h"
#include "array/darray_base.h"
#include "array/array_base.h"
namespace CNORXZ
{
@ -72,7 +72,7 @@ namespace CNORXZ
constexpr COpRoot() = default;
constexpr COpRoot(const DArrayBase<T>& a, const Sptr<IndexT>& ind);
constexpr COpRoot(const CArrayBase<T>& a, const Sptr<IndexT>& ind);
constexpr COpRoot(const T* data, const Sptr<IndexT>& ind);
constexpr COpRoot& init(const T* data, const Sptr<IndexT>& ind);
@ -141,7 +141,7 @@ namespace CNORXZ
constexpr OpRoot() = default;
constexpr OpRoot(MDArrayBase<T>& a, const Sptr<IndexT>& ind);
constexpr OpRoot(ArrayBase<T>& a, const Sptr<IndexT>& ind);
constexpr OpRoot(T* data, const Sptr<IndexT>& ind);
constexpr OpRoot& init(T* data, const Sptr<IndexT>& ind);

8
src/tests/CMakeLists.txt
View file

@ -17,10 +17,10 @@ add_dependencies(rutest cnorxz)
target_link_libraries(rutest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz test_lib)
add_test(NAME rutest COMMAND rutest)
add_executable(dautest darray_unit_test.cc)
add_dependencies(dautest cnorxz)
target_link_libraries(dautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz test_lib)
add_test(NAME dautest COMMAND dautest)
add_executable(mautest marray_unit_test.cc)
add_dependencies(mautest cnorxz)
target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} cnorxz test_lib)
add_test(NAME mautest COMMAND mautest)
add_executable(oputest operation_unit_test.cc)
add_dependencies(oputest cnorxz)

16
src/tests/darray_unit_test.cc → src/tests/marray_unit_test.cc
View file

@ -13,11 +13,11 @@ namespace
using namespace CNORXZ;
using Test::Numbers;
class DA_1D_Test : public ::testing::Test
class MA_1D_Test : public ::testing::Test
{
protected:
DA_1D_Test()
MA_1D_Test()
{
mSize = 7;
mCR1 = CRangeFactory(mSize).create();
@ -27,11 +27,11 @@ namespace
RangePtr mCR1;
};
class DA_2D_Test : public ::testing::Test
class MA_2D_Test : public ::testing::Test
{
protected:
DA_2D_Test()
MA_2D_Test()
{
mSize = 5;
mStrMeta = { "another", "test", "string", "vector", "for", "this", "Test" };
@ -45,9 +45,9 @@ namespace
RangePtr mUR1;
};
TEST_F(DA_1D_Test, Basics)
TEST_F(MA_1D_Test, Basics)
{
const DArray<Double> a(mCR1, Numbers::get(0,mSize));
const MArray<Double> a(mCR1, Numbers::get(0,mSize));
auto crx = std::dynamic_pointer_cast<CRange>(mCR1);
EXPECT_EQ(a.size(), mSize);
EXPECT_FALSE(a.isView());
@ -62,11 +62,11 @@ namespace
EXPECT_THROW({a.at(ei);}, std::runtime_error);
}
TEST_F(DA_2D_Test, Basics)
TEST_F(MA_2D_Test, Basics)
{
const SizeT ssize = mStrMeta.size();
const SizeT size = mSize * ssize;
const DArray<Double> a(mCR1*mUR1, Numbers::get(0,size));
const MArray<Double> a(mCR1*mUR1, Numbers::get(0,size));
EXPECT_EQ(a.range()->dim(), 2u);
EXPECT_EQ(a.size(), size);
EXPECT_EQ(a.pmax(), size);