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

rename MultiArray + pre-processor variables

Browse source
This commit is contained in:
Christian Zimmermann 2021-07-28 20:59:31 +02:00
parent c5e6003fc9
commit 3975edea20
69 changed files with 454 additions and 454 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/include/allocator.h
View file

@ -1,6 +1,6 @@
#ifndef __ma_allocator__ #ifndef __cxz_allocator__
#define __ma_allocator__ #define __cxz_allocator__
#include <cstdlib> #include <cstdlib>
#include <new> #include <new>

4
src/include/arith.h
View file

@ -1,6 +1,6 @@
#ifndef __arith_h__ #ifndef __cxz_arith_h__
#define __arith_h__ #define __cxz_arith_h__
#include <functional> #include <functional>

4
src/include/base_def.h
View file

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __base_def_h__ #ifndef __cxz_base_def_h__
#define __base_def_h__ #define __cxz_base_def_h__
#include <cassert> #include <cassert>

4
src/include/basic_types.h
View file

@ -1,5 +1,5 @@
#ifndef __basic_types_h__ #ifndef __cxz_basic_types_h__
#define __basic_types_h__ #define __cxz_basic_types_h__
#include <string> #include <string>

4
src/include/cnorxz.h
View file

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __cnorxz_h__ #ifndef __cxz_cnorxz_h__
#define __cnorxz_h__ #define __cxz_cnorxz_h__
#include <cstdlib> #include <cstdlib>
#include "container_index.h" #include "container_index.h"

4
src/include/container_index.h
View file

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __container_index_h__ #ifndef __cxz_container_index_h__
#define __container_index_h__ #define __cxz_container_index_h__
#include <cstdlib> #include <cstdlib>
#include <tuple> #include <tuple>

8
src/include/conversions.h
View file

@ -1,6 +1,6 @@
#ifndef __ma_conversions_h__ #ifndef __cxz_conversions_h__
#define __ma_conversions_h__ #define __cxz_conversions_h__
#include "cxz_array.h" #include "cxz_array.h"
#include "slice.h" #include "slice.h"
@ -94,7 +94,7 @@ namespace CNORXZ
} }
template <typename C, typename T, class... Ranges> template <typename C, typename T, class... Ranges>
auto tcast(MultiArray<T,Ranges...>& ma) auto tcast(Array<T,Ranges...>& ma)
-> decltype(rangeTpToSlice -> decltype(rangeTpToSlice
( rtcast<C,T>( ma.range()->space() ), ( rtcast<C,T>( ma.range()->space() ),
reinterpret_cast<C*>( ma.data() ) )) reinterpret_cast<C*>( ma.data() ) ))
@ -107,7 +107,7 @@ namespace CNORXZ
} }
template <typename C, typename T, class... Ranges> template <typename C, typename T, class... Ranges>
auto tcast(const MultiArray<T,Ranges...>& ma) auto tcast(const Array<T,Ranges...>& ma)
-> decltype(rangeTpToSlice -> decltype(rangeTpToSlice
( rtcast<C,T>( ma.range()->space() ), ( rtcast<C,T>( ma.range()->space() ),
reinterpret_cast<const C*>( ma.data() ) )) reinterpret_cast<const C*>( ma.data() ) ))

80
src/include/cxz_array.cc.h
View file

@ -12,21 +12,21 @@ namespace CNORXZ
} }
/******************* /*******************
* MultiArray * * Array *
*******************/ *******************/
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(const typename CRange::Space& space) : Array<T,SRanges...>::Array(const typename CRange::Space& space) :
MutableMultiArrayBase<T,SRanges...>(space), MutableArrayBase<T,SRanges...>(space),
mCont(MAB::mRange->size()) mCont(MAB::mRange->size())
{ {
MAB::mInit = true; MAB::mInit = true;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(const typename CRange::Space& space, Array<T,SRanges...>::Array(const typename CRange::Space& space,
const vector<T>& vec) : const vector<T>& vec) :
MutableMultiArrayBase<T,SRanges...>(space), MutableArrayBase<T,SRanges...>(space),
mCont(vec) mCont(vec)
{ {
MAB::mInit = true; MAB::mInit = true;
@ -37,24 +37,24 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges) : Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges) :
MutableMultiArrayBase<T,SRanges...>(ranges...), MutableArrayBase<T,SRanges...>(ranges...),
mCont(MAB::mRange->size()) mCont(MAB::mRange->size())
{ {
MAB::mInit = true; MAB::mInit = true;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, const T& val) : Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, const T& val) :
MutableMultiArrayBase<T,SRanges...>(ranges...), MutableArrayBase<T,SRanges...>(ranges...),
mCont(MAB::mRange->size(), val) mCont(MAB::mRange->size(), val)
{ {
MAB::mInit = true; MAB::mInit = true;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec) : Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec) :
MutableMultiArrayBase<T,SRanges...>(ranges...), MutableArrayBase<T,SRanges...>(ranges...),
mCont(vec) mCont(vec)
{ {
MAB::mInit = true; MAB::mInit = true;
@ -64,8 +64,8 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec) : Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec) :
MutableMultiArrayBase<T,SRanges...>(ranges...), MutableArrayBase<T,SRanges...>(ranges...),
mCont(std::forward<vector<T>>(vec)) mCont(std::forward<vector<T>>(vec))
{ {
MAB::mInit = true; MAB::mInit = true;
@ -76,8 +76,8 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... Ranges> template <class... Ranges>
MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, MultiArray<T,Ranges...>&& in) : Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, Array<T,Ranges...>&& in) :
MutableMultiArrayBase<T,SRanges...>(ranges...), MutableArrayBase<T,SRanges...>(ranges...),
mCont( std::move( in.mCont ) ) mCont( std::move( in.mCont ) )
{ {
// maybe some checks here in the future... // maybe some checks here in the future...
@ -87,8 +87,8 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::MultiArray(MultiArray<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes) : Array<T,SRanges...>::Array(Array<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes) :
MutableMultiArrayBase<T,SRanges...> MutableArrayBase<T,SRanges...>
( ama.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ), ( ama.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ),
mCont( std::move( ama.mCont ) ) mCont( std::move( ama.mCont ) )
{ {
@ -97,85 +97,85 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
T& MultiArray<T,SRanges...>::operator[](const IndexType& i) T& Array<T,SRanges...>::operator[](const IndexType& i)
{ {
return mCont[ i.pos() ]; return mCont[ i.pos() ];
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
const T& MultiArray<T,SRanges...>::operator[](const IndexType& i) const const T& Array<T,SRanges...>::operator[](const IndexType& i) const
{ {
return mCont[ i.pos() ]; return mCont[ i.pos() ];
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
T& MultiArray<T,SRanges...>::at(const typename IndexType::MetaType& meta) T& Array<T,SRanges...>::at(const typename IndexType::MetaType& meta)
{ {
return mCont[ MAB::cbegin().at(meta).pos() ]; return mCont[ MAB::cbegin().at(meta).pos() ];
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
const T& MultiArray<T,SRanges...>::at(const typename IndexType::MetaType& meta) const const T& Array<T,SRanges...>::at(const typename IndexType::MetaType& meta) const
{ {
return mCont[ MAB::cbegin().at(meta).pos() ]; return mCont[ MAB::cbegin().at(meta).pos() ];
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
bool MultiArray<T,SRanges...>::isConst() const bool Array<T,SRanges...>::isConst() const
{ {
return false; return false;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
bool MultiArray<T,SRanges...>::isSlice() const bool Array<T,SRanges...>::isSlice() const
{ {
return false; return false;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... SRanges2> template <class... SRanges2>
MultiArray<T,SRanges2...> MultiArray<T,SRanges...>::format(const std::shared_ptr<SRanges2>&... nrs) Array<T,SRanges2...> Array<T,SRanges...>::format(const std::shared_ptr<SRanges2>&... nrs)
{ {
//MAB::mInit = false; //MAB::mInit = false;
return MultiArray<T,SRanges2...>( nrs... , mCont ); return Array<T,SRanges2...>( nrs... , mCont );
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... SRanges2> template <class... SRanges2>
MultiArray<T,SRanges2...> MultiArray<T,SRanges...>::format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs) Array<T,SRanges2...> Array<T,SRanges...>::format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs)
{ {
//MAB::mInit = false; //MAB::mInit = false;
return MultiArray<T,SRanges2...>( nrs , mCont ); return Array<T,SRanges2...>( nrs , mCont );
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... SRanges2> template <class... SRanges2>
Slice<T,SRanges2...> MultiArray<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs) Slice<T,SRanges2...> Array<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs)
{ {
return Slice<T,SRanges2...>( nrs..., mCont.data() ); return Slice<T,SRanges2...>( nrs..., mCont.data() );
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... SRanges2> template <class... SRanges2>
ConstSlice<T,SRanges2...> MultiArray<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs) const ConstSlice<T,SRanges2...> Array<T,SRanges...>::slformat(const std::shared_ptr<SRanges2>&... nrs) const
{ {
return ConstSlice<T,SRanges2...>( nrs..., mCont.data() ); return ConstSlice<T,SRanges2...>( nrs..., mCont.data() );
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
const T* MultiArray<T,SRanges...>::data() const const T* Array<T,SRanges...>::data() const
{ {
return mCont.data(); return mCont.data();
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
T* MultiArray<T,SRanges...>::data() T* Array<T,SRanges...>::data()
{ {
return mCont.data(); return mCont.data();
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
std::shared_ptr<MultiArrayBase<T,AnonymousRange> > MultiArray<T,SRanges...>::anonymous(bool slice) const std::shared_ptr<ArrayBase<T,AnonymousRange> > Array<T,SRanges...>::anonymous(bool slice) const
{ {
AnonymousRangeFactory arf(MAB::mRange->space()); AnonymousRangeFactory arf(MAB::mRange->space());
if(slice){ if(slice){
@ -184,14 +184,14 @@ namespace CNORXZ
data() ); data() );
} }
else { else {
return std::make_shared<MultiArray<T,AnonymousRange> > return std::make_shared<Array<T,AnonymousRange> >
( std::dynamic_pointer_cast<AnonymousRange>( arf.create() ), ( std::dynamic_pointer_cast<AnonymousRange>( arf.create() ),
mCont ); mCont );
} }
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator=(const T& in) Array<T,SRanges...>& Array<T,SRanges...>::operator=(const T& in)
{ {
for(auto& x: mCont){ for(auto& x: mCont){
x = in; x = in;
@ -200,7 +200,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator+=(const MultiArray& in) Array<T,SRanges...>& Array<T,SRanges...>::operator+=(const Array& in)
{ {
if(not MAB::mInit){ // not initialized by default constructor !! if(not MAB::mInit){ // not initialized by default constructor !!
(*this) = in; (*this) = in;
@ -217,7 +217,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator-=(const MultiArray& in) Array<T,SRanges...>& Array<T,SRanges...>::operator-=(const Array& in)
{ {
if(not MAB::mInit){ // not initialized by default constructor !! if(not MAB::mInit){ // not initialized by default constructor !!
(*this) = in; (*this) = in;
@ -234,7 +234,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator*=(const T& in) Array<T,SRanges...>& Array<T,SRanges...>::operator*=(const T& in)
{ {
for(auto& x: mCont){ for(auto& x: mCont){
x *= in; x *= in;
@ -243,7 +243,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>& MultiArray<T,SRanges...>::operator/=(const T& in) Array<T,SRanges...>& Array<T,SRanges...>::operator/=(const T& in)
{ {
for(auto& x: mCont){ for(auto& x: mCont){
x /= in; x /= in;
@ -252,7 +252,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArray<T,SRanges...>::operator T() const Array<T,SRanges...>::operator T() const
{ {
//static_assert( sizeof...(SRanges) == 1, "try to cast non-scalar type into scalar" ); //static_assert( sizeof...(SRanges) == 1, "try to cast non-scalar type into scalar" );
// TODO: check that SIZE is statically = 1 !!! // TODO: check that SIZE is statically = 1 !!!
@ -260,7 +260,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
auto MultiArray<T,SRanges...>::cat() const auto Array<T,SRanges...>::cat() const
-> decltype(ArrayCatter<T>::cat(*this)) -> decltype(ArrayCatter<T>::cat(*this))
{ {
return ArrayCatter<T>::cat(*this); return ArrayCatter<T>::cat(*this);

70
src/include/cxz_array.h
View file

@ -18,49 +18,49 @@ namespace CNORXZ
struct ArrayCatter struct ArrayCatter
{ {
template <class... Ranges> template <class... Ranges>
static auto cat(const MultiArray<T,Ranges...>& ma) static auto cat(const Array<T,Ranges...>& ma)
-> MultiArray<T,Ranges...> -> Array<T,Ranges...>
{ {
return ma; return ma;
} }
}; };
template <typename T, class... SRanges> template <typename T, class... SRanges>
class MultiArray : public MutableMultiArrayBase<T,SRanges...> class Array : public MutableArrayBase<T,SRanges...>
{ {
public: public:
typedef ContainerRange<SRanges...> CRange; typedef ContainerRange<SRanges...> CRange;
typedef MultiArrayBase<T,SRanges...> MAB; typedef ArrayBase<T,SRanges...> MAB;
typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType; typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
using MultiArrayBase<T,SRanges...>::operator[]; using ArrayBase<T,SRanges...>::operator[];
using MutableMultiArrayBase<T,SRanges...>::operator[]; using MutableArrayBase<T,SRanges...>::operator[];
DEFAULT_MEMBERS(MultiArray); DEFAULT_MEMBERS(Array);
MultiArray(const std::shared_ptr<SRanges>&... ranges); Array(const std::shared_ptr<SRanges>&... ranges);
MultiArray(const std::shared_ptr<SRanges>&... ranges, const T& val); Array(const std::shared_ptr<SRanges>&... ranges, const T& val);
MultiArray(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec); Array(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec);
MultiArray(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec); Array(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec);
template <class... Ranges> template <class... Ranges>
MultiArray(const std::shared_ptr<SRanges>&... ranges, MultiArray<T,Ranges...>&& in); // same effect as format Array(const std::shared_ptr<SRanges>&... ranges, Array<T,Ranges...>&& in); // same effect as format
MultiArray(const typename CRange::Space& space); Array(const typename CRange::Space& space);
MultiArray(const typename CRange::Space& space, const vector<T>& vec); Array(const typename CRange::Space& space, const vector<T>& vec);
MultiArray(MultiArray<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes); Array(Array<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes);
// Only if ALL ranges have default extensions: // Only if ALL ranges have default extensions:
//MultiArray(const vector<T>& vec); //Array(const vector<T>& vec);
//MultiArray(vector<T>&& vec); //Array(vector<T>&& vec);
// template <class Range2, class Range3> // template <class Range2, class Range3>
// MultiArray(const MultiArray<MultiArray<T,Range2>,Range3> in); // Array(const Array<Array<T,Range2>,Range3> in);
// implement contstructor using FunctionalMultiArray as Input !!! // implement contstructor using FunctionalArray as Input !!!
//template <class Range2, class Range3> //template <class Range2, class Range3>
//MultiArray& operator=(const MultiArray<MultiArray<T,Range2>,Range3> in); //Array& operator=(const Array<Array<T,Range2>,Range3> in);
virtual T& operator[](const IndexType& i) final; virtual T& operator[](const IndexType& i) final;
virtual const T& operator[](const IndexType& i) const final; virtual const T& operator[](const IndexType& i) const final;
@ -71,11 +71,11 @@ namespace CNORXZ
virtual bool isSlice() const override; virtual bool isSlice() const override;
template <class... SRanges2> template <class... SRanges2>
MultiArray<T,SRanges2...> format(const std::shared_ptr<SRanges2>&... nrs); // reformat array using 'nr' which in Array<T,SRanges2...> format(const std::shared_ptr<SRanges2>&... nrs); // reformat array using 'nr' which in
// total must have the same size as mRange // total must have the same size as mRange
template <class... SRanges2> template <class... SRanges2>
MultiArray<T,SRanges2...> format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs); Array<T,SRanges2...> format(const std::tuple<std::shared_ptr<SRanges2>...>& nrs);
template <class... SRanges2> template <class... SRanges2>
Slice<T,SRanges2...> slformat(const std::shared_ptr<SRanges2>&... nrs); Slice<T,SRanges2...> slformat(const std::shared_ptr<SRanges2>&... nrs);
@ -89,23 +89,23 @@ namespace CNORXZ
virtual const vector<T>& vdata() const { return mCont; } virtual const vector<T>& vdata() const { return mCont; }
vector<T>&& vmove() { MAB::mInit = false; return std::move(mCont); } vector<T>&& vmove() { MAB::mInit = false; return std::move(mCont); }
virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override; virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
//virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymousMove() override; //virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymousMove() override;
auto cat() const auto cat() const
-> decltype(ArrayCatter<T>::cat(*this)); -> decltype(ArrayCatter<T>::cat(*this));
operator T() const; operator T() const;
MultiArray& operator=(const T& in); Array& operator=(const T& in);
MultiArray& operator+=(const MultiArray& in); Array& operator+=(const Array& in);
MultiArray& operator-=(const MultiArray& in); Array& operator-=(const Array& in);
MultiArray& operator*=(const T& in); Array& operator*=(const T& in);
MultiArray& operator/=(const T& in); Array& operator/=(const T& in);
template <typename U, class... SRanges2> template <typename U, class... SRanges2>
friend class MultiArray; friend class Array;
private: private:
@ -113,17 +113,17 @@ namespace CNORXZ
}; };
template <typename T> template <typename T>
using Scalar = MultiArray<T,NullRange>; using Scalar = Array<T,NullRange>;
template <typename T> template <typename T>
Scalar<T> scalar(const T& in); Scalar<T> scalar(const T& in);
template <typename T, class... ERanges> template <typename T, class... ERanges>
struct ArrayCatter<MultiArray<T,ERanges...> > struct ArrayCatter<Array<T,ERanges...> >
{ {
template <class... Ranges> template <class... Ranges>
static auto cat(const MultiArray<MultiArray<T,ERanges...>,Ranges...>& ma) static auto cat(const Array<Array<T,ERanges...>,Ranges...>& ma)
-> MultiArray<T,Ranges...,ERanges...> -> Array<T,Ranges...,ERanges...>
{ {
auto sma = *ma.begin(); auto sma = *ma.begin();
const size_t smas = sma.size(); const size_t smas = sma.size();
@ -136,7 +136,7 @@ namespace CNORXZ
assert(x.size() == smas); assert(x.size() == smas);
ov.insert(ov.end(), x.vdata().begin(), x.vdata().end()); ov.insert(ov.end(), x.vdata().begin(), x.vdata().end());
} }
return MultiArray<T,Ranges...,ERanges...>(cr->space(), std::move(ov)); return Array<T,Ranges...,ERanges...>(cr->space(), std::move(ov));
} }
}; };

76
src/include/cxz_array_base.cc.h
View file

@ -5,11 +5,11 @@ namespace CNORXZ
{ {
/********************** /**********************
* MultiArrayBase * * ArrayBase *
**********************/ **********************/
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArrayBase<T,SRanges...>::MultiArrayBase(const MultiArrayBase& in) : ArrayBase<T,SRanges...>::ArrayBase(const ArrayBase& in) :
mInit(in.mInit), mInit(in.mInit),
mRange(in.mRange) mRange(in.mRange)
{ {
@ -20,7 +20,7 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArrayBase<T,SRanges...>::MultiArrayBase(MultiArrayBase&& in) : ArrayBase<T,SRanges...>::ArrayBase(ArrayBase&& in) :
mInit(in.mInit), mInit(in.mInit),
mRange(in.mRange) mRange(in.mRange)
{ {
@ -30,7 +30,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArrayBase<T,SRanges...>& MultiArrayBase<T,SRanges...>::operator=(const MultiArrayBase& in) ArrayBase<T,SRanges...>& ArrayBase<T,SRanges...>::operator=(const ArrayBase& in)
{ {
mInit = in.mInit; mInit = in.mInit;
mRange = in.mRange; mRange = in.mRange;
@ -41,7 +41,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArrayBase<T,SRanges...>& MultiArrayBase<T,SRanges...>::operator=(MultiArrayBase&& in) ArrayBase<T,SRanges...>& ArrayBase<T,SRanges...>::operator=(ArrayBase&& in)
{ {
mInit = in.mInit; mInit = in.mInit;
mRange = in.mRange; mRange = in.mRange;
@ -52,7 +52,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArrayBase<T,SRanges...>::MultiArrayBase(const std::shared_ptr<SRanges>&... ranges) ArrayBase<T,SRanges...>::ArrayBase(const std::shared_ptr<SRanges>&... ranges)
{ {
ContainerRangeFactory<SRanges...> crf(ranges...); ContainerRangeFactory<SRanges...> crf(ranges...);
mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() ); mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
@ -60,7 +60,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
MultiArrayBase<T,SRanges...>::MultiArrayBase(const typename CRange::Space& space) ArrayBase<T,SRanges...>::ArrayBase(const typename CRange::Space& space)
{ {
ContainerRangeFactory<SRanges...> crf(space); ContainerRangeFactory<SRanges...> crf(space);
mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() ); mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
@ -69,7 +69,7 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <typename X> template <typename X>
const T& MultiArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i) const T& ArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
{ {
IndexType ii(*mProtoI); IndexType ii(*mProtoI);
ii = i; ii = i;
@ -77,7 +77,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
const T& MultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const const T& ArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) const
{ {
IndexType ii(*mProtoI); IndexType ii(*mProtoI);
ii(is); ii(is);
@ -85,25 +85,25 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
size_t MultiArrayBase<T,SRanges...>::size() const size_t ArrayBase<T,SRanges...>::size() const
{ {
return mRange->size(); return mRange->size();
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::begin() const typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::begin() const
{ {
return cbegin(); return cbegin();
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::end() const typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::end() const
{ {
return end(); return end();
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::cbegin() const typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::cbegin() const
{ {
CIndexType i(*mProtoI,true); CIndexType i(*mProtoI,true);
i = 0; i = 0;
@ -111,7 +111,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
typename MultiArrayBase<T,SRanges...>::CIndexType MultiArrayBase<T,SRanges...>::cend() const typename ArrayBase<T,SRanges...>::CIndexType ArrayBase<T,SRanges...>::cend() const
{ {
CIndexType i(*mProtoI,true); CIndexType i(*mProtoI,true);
i = i.max(); i = i.max();
@ -119,28 +119,28 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
const std::shared_ptr<typename MultiArrayBase<T,SRanges...>::CRange>& const std::shared_ptr<typename ArrayBase<T,SRanges...>::CRange>&
MultiArrayBase<T,SRanges...>::range() const ArrayBase<T,SRanges...>::range() const
{ {
return mRange; return mRange;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
bool MultiArrayBase<T,SRanges...>::isConst() const bool ArrayBase<T,SRanges...>::isConst() const
{ {
return true; return true;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstOperationRoot<T,SRanges...> ConstOperationRoot<T,SRanges...>
MultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const ArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
{ {
return ConstOperationRoot<T,SRanges...>(*this, inds...); return ConstOperationRoot<T,SRanges...>(*this, inds...);
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstOperationRoot<T,SRanges...> ConstOperationRoot<T,SRanges...>
MultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const ArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
{ {
return ConstOperationRoot<T,SRanges...>(data(), *ind); return ConstOperationRoot<T,SRanges...>(data(), *ind);
} }
@ -148,7 +148,7 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... MappedRanges> template <class... MappedRanges>
ConstOperationRoot<T,MappedRanges...> ConstOperationRoot<T,MappedRanges...>
MultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const ArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
{ {
static_assert(sizeof...(SRanges) == sizeof...(MappedRanges), static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
"number of mapped ranges must be equal to number of original ranges"); "number of mapped ranges must be equal to number of original ranges");
@ -156,14 +156,14 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
bool MultiArrayBase<T,SRanges...>::isInit() const bool ArrayBase<T,SRanges...>::isInit() const
{ {
return mInit; return mInit;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <size_t N> template <size_t N>
auto MultiArrayBase<T,SRanges...>::getRangePtr() const auto ArrayBase<T,SRanges...>::getRangePtr() const
-> decltype(mRange->template getPtr<N>()) -> decltype(mRange->template getPtr<N>())
{ {
return mRange->template getPtr<N>(); return mRange->template getPtr<N>();
@ -171,20 +171,20 @@ namespace CNORXZ
/****************************** /******************************
* MutableMultiArrayBase * * MutableArrayBase *
******************************/ ******************************/
template <typename T, class... SRanges> template <typename T, class... SRanges>
MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges) : MutableArrayBase<T,SRanges...>::MutableArrayBase(const std::shared_ptr<SRanges>&... ranges) :
MultiArrayBase<T,SRanges...>(ranges...) {} ArrayBase<T,SRanges...>(ranges...) {}
template <typename T, class... SRanges> template <typename T, class... SRanges>
MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const typename CRange::Space& space) : MutableArrayBase<T,SRanges...>::MutableArrayBase(const typename CRange::Space& space) :
MultiArrayBase<T,SRanges...>(space) {} ArrayBase<T,SRanges...>(space) {}
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <typename X> template <typename X>
T& MutableMultiArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i) T& MutableArrayBase<T,SRanges...>::operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i)
{ {
IndexType ii(*MAB::mProtoI); IndexType ii(*MAB::mProtoI);
ii = i; ii = i;
@ -192,7 +192,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
T& MutableMultiArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is) T& MutableArrayBase<T,SRanges...>::operator[](const std::tuple<IPTR<typename SRanges::IndexType>...>& is)
{ {
IndexType ii(*MAB::mProtoI,this->data()); IndexType ii(*MAB::mProtoI,this->data());
ii(is); ii(is);
@ -200,7 +200,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::begin() typename MutableArrayBase<T,SRanges...>::IndexType MutableArrayBase<T,SRanges...>::begin()
{ {
IndexType i(*MAB::mProtoI,this->data(),true); IndexType i(*MAB::mProtoI,this->data(),true);
i = 0; i = 0;
@ -208,7 +208,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
typename MutableMultiArrayBase<T,SRanges...>::IndexType MutableMultiArrayBase<T,SRanges...>::end() typename MutableArrayBase<T,SRanges...>::IndexType MutableArrayBase<T,SRanges...>::end()
{ {
IndexType i(*MAB::mProtoI,this->data(),true); IndexType i(*MAB::mProtoI,this->data(),true);
i = i.max(); i = i.max();
@ -217,35 +217,35 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
bool MutableMultiArrayBase<T,SRanges...>::isConst() const bool MutableArrayBase<T,SRanges...>::isConst() const
{ {
return false; return false;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
OperationRoot<T,SRanges...> OperationRoot<T,SRanges...>
MutableMultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) MutableArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds)
{ {
return OperationRoot<T,SRanges...>(*this, inds...); return OperationRoot<T,SRanges...>(*this, inds...);
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
OperationRoot<T,SRanges...> OperationRoot<T,SRanges...>
MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) MutableArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind)
{ {
return OperationRoot<T,SRanges...>(data(), *ind); return OperationRoot<T,SRanges...>(data(), *ind);
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstOperationRoot<T,SRanges...> ConstOperationRoot<T,SRanges...>
MutableMultiArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const MutableArrayBase<T,SRanges...>::operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
{ {
return ConstOperationRoot<T,SRanges...>(*this, inds...); return ConstOperationRoot<T,SRanges...>(*this, inds...);
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstOperationRoot<T,SRanges...> ConstOperationRoot<T,SRanges...>
MutableMultiArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const MutableArrayBase<T,SRanges...>::op(const std::shared_ptr<CIndexType>& ind) const
{ {
return ConstOperationRoot<T,SRanges...>(data(), *ind); return ConstOperationRoot<T,SRanges...>(data(), *ind);
} }
@ -253,7 +253,7 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... MappedRanges> template <class... MappedRanges>
OperationRoot<T,MappedRanges...> OperationRoot<T,MappedRanges...>
MutableMultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) MutableArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds)
{ {
static_assert(sizeof...(SRanges) == sizeof...(MappedRanges), static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
"number of mapped ranges must be equal to number of original ranges"); "number of mapped ranges must be equal to number of original ranges");
@ -263,7 +263,7 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
template <class... MappedRanges> template <class... MappedRanges>
ConstOperationRoot<T,MappedRanges...> ConstOperationRoot<T,MappedRanges...>
MutableMultiArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const MutableArrayBase<T,SRanges...>::m(const std::shared_ptr<typename MappedRanges::IndexType>&... inds) const
{ {
static_assert(sizeof...(SRanges) == sizeof...(MappedRanges), static_assert(sizeof...(SRanges) == sizeof...(MappedRanges),
"number of mapped ranges must be equal to number of original ranges"); "number of mapped ranges must be equal to number of original ranges");

46
src/include/cxz_array_base.h
View file

@ -51,7 +51,7 @@ namespace CNORXZ
// Explicitely specify subranges in template argument !!! // Explicitely specify subranges in template argument !!!
template <typename T, class... SRanges> template <typename T, class... SRanges>
class MultiArrayBase class ArrayBase
{ {
public: public:
@ -67,17 +67,17 @@ namespace CNORXZ
public: public:
//DEFAULT_MEMBERS(MultiArrayBase); //DEFAULT_MEMBERS(ArrayBase);
MultiArrayBase(const std::shared_ptr<SRanges>&... ranges); ArrayBase(const std::shared_ptr<SRanges>&... ranges);
MultiArrayBase(const typename CRange::Space& space); ArrayBase(const typename CRange::Space& space);
MultiArrayBase() = default; ArrayBase() = default;
MultiArrayBase(const MultiArrayBase& in); ArrayBase(const ArrayBase& in);
MultiArrayBase(MultiArrayBase&& in); ArrayBase(ArrayBase&& in);
MultiArrayBase& operator=(const MultiArrayBase& in); ArrayBase& operator=(const ArrayBase& in);
MultiArrayBase& operator=(MultiArrayBase&& in); ArrayBase& operator=(ArrayBase&& in);
virtual ~MultiArrayBase() = default; virtual ~ArrayBase() = default;
template <typename X> template <typename X>
const T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i); const T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
@ -100,7 +100,7 @@ namespace CNORXZ
virtual bool isConst() const; virtual bool isConst() const;
virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const = 0; virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const = 0;
virtual ConstOperationRoot<T,SRanges...> virtual ConstOperationRoot<T,SRanges...>
op(const std::shared_ptr<CIndexType>& ind) const; op(const std::shared_ptr<CIndexType>& ind) const;
@ -121,26 +121,26 @@ namespace CNORXZ
}; };
template <typename T, class... SRanges> template <typename T, class... SRanges>
class MutableMultiArrayBase : public MultiArrayBase<T,SRanges...> class MutableArrayBase : public ArrayBase<T,SRanges...>
{ {
public: public:
typedef ContainerRange<SRanges...> CRange; typedef ContainerRange<SRanges...> CRange;
typedef MultiArrayBase<T,SRanges...> MAB; typedef ArrayBase<T,SRanges...> MAB;
typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType; typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
typedef ConstContainerIndex<T,typename SRanges::IndexType...> CIndexType; typedef ConstContainerIndex<T,typename SRanges::IndexType...> CIndexType;
using MultiArrayBase<T,SRanges...>::operator[]; using ArrayBase<T,SRanges...>::operator[];
using MultiArrayBase<T,SRanges...>::at; using ArrayBase<T,SRanges...>::at;
using MultiArrayBase<T,SRanges...>::data; using ArrayBase<T,SRanges...>::data;
using MultiArrayBase<T,SRanges...>::begin; using ArrayBase<T,SRanges...>::begin;
using MultiArrayBase<T,SRanges...>::end; using ArrayBase<T,SRanges...>::end;
using MultiArrayBase<T,SRanges...>::cbegin; using ArrayBase<T,SRanges...>::cbegin;
using MultiArrayBase<T,SRanges...>::cend; using ArrayBase<T,SRanges...>::cend;
DEFAULT_MEMBERS(MutableMultiArrayBase); DEFAULT_MEMBERS(MutableArrayBase);
MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges); MutableArrayBase(const std::shared_ptr<SRanges>&... ranges);
MutableMultiArrayBase(const typename CRange::Space& space); MutableArrayBase(const typename CRange::Space& space);
template <typename X> template <typename X>
T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i); T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);

0
src/include/ma_assert.h → src/include/cxz_assert.h
View file

20
src/include/cxz_operation.cc.h
View file

@ -68,7 +68,7 @@ namespace CNORXZ
template <class... Indices> template <class... Indices>
auto OperationBase<T,OperationClass>::p(const std::shared_ptr<Indices>&... inds) const auto OperationBase<T,OperationClass>::p(const std::shared_ptr<Indices>&... inds) const
{ {
auto ma = std::make_shared<MultiArray<T,typename Indices::RangeType...>> auto ma = std::make_shared<Array<T,typename Indices::RangeType...>>
(inds->range()... , static_cast<T>(0)); (inds->range()... , static_cast<T>(0));
(*ma)(inds...) = THIS(); (*ma)(inds...) = THIS();
return ConstOperationRoot<T,typename Indices::RangeType...>(ma, inds...); return ConstOperationRoot<T,typename Indices::RangeType...>(ma, inds...);
@ -78,7 +78,7 @@ namespace CNORXZ
template <class... Indices> template <class... Indices>
auto OperationBase<T,OperationClass>::to(const std::shared_ptr<Indices>&... inds) const auto OperationBase<T,OperationClass>::to(const std::shared_ptr<Indices>&... inds) const
{ {
MultiArray<T,typename Indices::RangeType...> out(inds->range()...); Array<T,typename Indices::RangeType...> out(inds->range()...);
out(inds...) = THIS(); out(inds...) = THIS();
return out; return out;
} }
@ -87,7 +87,7 @@ namespace CNORXZ
template <class... Indices> template <class... Indices>
auto OperationBase<T,OperationClass>::addto(const std::shared_ptr<Indices>&... inds) const auto OperationBase<T,OperationClass>::addto(const std::shared_ptr<Indices>&... inds) const
{ {
MultiArray<T,typename Indices::RangeType...> out(inds->range()..., Array<T,typename Indices::RangeType...> out(inds->range()...,
static_cast<T>(0)); static_cast<T>(0));
out(inds...) += THIS(); out(inds...) += THIS();
return out; return out;
@ -97,7 +97,7 @@ namespace CNORXZ
template <class... Indices> template <class... Indices>
auto OperationBase<T,OperationClass>::pto(const std::shared_ptr<Indices>&... inds) const auto OperationBase<T,OperationClass>::pto(const std::shared_ptr<Indices>&... inds) const
{ {
MultiArray<T,typename Indices::RangeType...> out(inds->range()...); Array<T,typename Indices::RangeType...> out(inds->range()...);
out(inds...).par() = THIS(); out(inds...).par() = THIS();
return out; return out;
} }
@ -106,7 +106,7 @@ namespace CNORXZ
template <class... Indices> template <class... Indices>
auto OperationBase<T,OperationClass>::paddto(const std::shared_ptr<Indices>&... inds) const auto OperationBase<T,OperationClass>::paddto(const std::shared_ptr<Indices>&... inds) const
{ {
MultiArray<T,typename Indices::RangeType...> out(inds->range()..., Array<T,typename Indices::RangeType...> out(inds->range()...,
static_cast<T>(0)); static_cast<T>(0));
out(inds...).par() += THIS(); out(inds...).par() += THIS();
return out; return out;
@ -343,7 +343,7 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
ConstOperationRoot<T,Ranges...>:: ConstOperationRoot<T,Ranges...>::
ConstOperationRoot(const MultiArrayBase<T,Ranges...>& ma, ConstOperationRoot(const ArrayBase<T,Ranges...>& ma,
const std::shared_ptr<typename Ranges::IndexType>&... indices) : const std::shared_ptr<typename Ranges::IndexType>&... indices) :
mDataPtr(ma.data()), mDataPtr(ma.data()),
mOrigDataPtr(ma.data()), mOrigDataPtr(ma.data()),
@ -355,7 +355,7 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
ConstOperationRoot<T,Ranges...>:: ConstOperationRoot<T,Ranges...>::
ConstOperationRoot(std::shared_ptr<MultiArrayBase<T,Ranges...> > maptr, ConstOperationRoot(std::shared_ptr<ArrayBase<T,Ranges...> > maptr,
const std::shared_ptr<typename Ranges::IndexType>&... indices) : const std::shared_ptr<typename Ranges::IndexType>&... indices) :
mDataPtr(maptr->data()), mDataPtr(maptr->data()),
mOrigDataPtr(maptr->data()), mOrigDataPtr(maptr->data()),
@ -517,7 +517,7 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
OperationRoot<T,Ranges...>:: OperationRoot<T,Ranges...>::
OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma, OperationRoot(MutableArrayBase<T,Ranges...>& ma,
const std::shared_ptr<typename Ranges::IndexType>&... indices) : const std::shared_ptr<typename Ranges::IndexType>&... indices) :
mDataPtr(ma.data()), mDataPtr(ma.data()),
mOrigDataPtr(ma.data()), mOrigDataPtr(ma.data()),
@ -531,7 +531,7 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
OperationRoot<T,Ranges...>:: OperationRoot<T,Ranges...>::
OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma, OperationRoot(MutableArrayBase<T,Ranges...>& ma,
const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices) : const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices) :
mDataPtr(ma.data()), mDataPtr(ma.data()),
mOrigDataPtr(ma.data()), mOrigDataPtr(ma.data()),
@ -728,7 +728,7 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
ParallelOperationRoot<T,Ranges...>:: ParallelOperationRoot<T,Ranges...>::
ParallelOperationRoot(MutableMultiArrayBase<T,Ranges...>& ma, ParallelOperationRoot(MutableArrayBase<T,Ranges...>& ma,
const std::shared_ptr<typename Ranges::IndexType>&... indices) : const std::shared_ptr<typename Ranges::IndexType>&... indices) :
mDataPtr(ma.data()), mDataPtr(ma.data()),
mOrigDataPtr(ma.data()), mOrigDataPtr(ma.data()),

12
src/include/cxz_operation.h
View file

@ -477,10 +477,10 @@ namespace CNORXZ
static constexpr bool CONT = true; static constexpr bool CONT = true;
static constexpr bool VABLE = true; static constexpr bool VABLE = true;
ConstOperationRoot(const MultiArrayBase<T,Ranges...>& ma, ConstOperationRoot(const ArrayBase<T,Ranges...>& ma,
const std::shared_ptr<typename Ranges::IndexType>&... indices); const std::shared_ptr<typename Ranges::IndexType>&... indices);
ConstOperationRoot(std::shared_ptr<MultiArrayBase<T,Ranges...> > maptr, ConstOperationRoot(std::shared_ptr<ArrayBase<T,Ranges...> > maptr,
const std::shared_ptr<typename Ranges::IndexType>&... indices); const std::shared_ptr<typename Ranges::IndexType>&... indices);
ConstOperationRoot(const T* data, const IndexType& ind); ConstOperationRoot(const T* data, const IndexType& ind);
@ -506,7 +506,7 @@ namespace CNORXZ
const T* mDataPtr; const T* mDataPtr;
const T* mOrigDataPtr; const T* mOrigDataPtr;
IndexType mIndex; IndexType mIndex;
std::shared_ptr<MultiArrayBase<T,Ranges...> > mMaPtr; // never remove this ptr, otherwise we lose temporary container instances! std::shared_ptr<ArrayBase<T,Ranges...> > mMaPtr; // never remove this ptr, otherwise we lose temporary container instances!
}; };
template <typename T, class Op> template <typename T, class Op>
@ -609,10 +609,10 @@ namespace CNORXZ
IndexType mIndex; IndexType mIndex;
public: public:
OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma, OperationRoot(MutableArrayBase<T,Ranges...>& ma,
const std::shared_ptr<typename Ranges::IndexType>&... indices); const std::shared_ptr<typename Ranges::IndexType>&... indices);
OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma, OperationRoot(MutableArrayBase<T,Ranges...>& ma,
const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices); const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices);
OperationRoot(T* data, const IndexType& ind); OperationRoot(T* data, const IndexType& ind);
@ -695,7 +695,7 @@ namespace CNORXZ
IndexType mIndex; IndexType mIndex;
public: public:
ParallelOperationRoot(MutableMultiArrayBase<T,Ranges...>& ma, ParallelOperationRoot(MutableArrayBase<T,Ranges...>& ma,
const std::shared_ptr<typename Ranges::IndexType>&... indices); const std::shared_ptr<typename Ranges::IndexType>&... indices);
ParallelOperationRoot(T* data, const IndexType& ind); ParallelOperationRoot(T* data, const IndexType& ind);

12
src/include/dynamic_operation.cc.h
View file

@ -45,7 +45,7 @@ namespace CNORXZ
DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const DynamicOuterOp& in) : DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const DynamicOuterOp& in) :
mThreadId(omp_get_thread_num()), mOp(in.mOp), mThreadId(omp_get_thread_num()), mOp(in.mOp),
mIndices(in.mIndices), mIndices(in.mIndices),
mMa((mThreadId != in.mThreadId) ? std::make_shared<MultiArray<T,Ranges...>>(*in.mMa) : in.mMa), mMa((mThreadId != in.mThreadId) ? std::make_shared<Array<T,Ranges...>>(*in.mMa) : in.mMa),
mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto), mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto),
mL((mThreadId != in.mThreadId) ? mL((mThreadId != in.mThreadId) ?
mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices, mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
@ -60,7 +60,7 @@ namespace CNORXZ
DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(DynamicOuterOp&& in) : DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(DynamicOuterOp&& in) :
mThreadId(omp_get_thread_num()), mOp(in.mOp), mThreadId(omp_get_thread_num()), mOp(in.mOp),
mIndices(in.mIndices), mIndices(in.mIndices),
mMa((mThreadId != in.mThreadId) ? std::make_shared<MultiArray<T,Ranges...>>(*in.mMa) : in.mMa), mMa((mThreadId != in.mThreadId) ? std::make_shared<Array<T,Ranges...>>(*in.mMa) : in.mMa),
mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto), mProto((mThreadId != in.mThreadId) ? OperationRoot<T,Ranges...>(*mMa,mIndices) : in.mProto),
mL((mThreadId != in.mThreadId) ? mL((mThreadId != in.mThreadId) ?
mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices, mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
@ -79,7 +79,7 @@ namespace CNORXZ
mOp = in.mOp; mOp = in.mOp;
mIndices = in.mIndices; mIndices = in.mIndices;
if(mThreadId != in.mThreadId){ if(mThreadId != in.mThreadId){
mMa = std::make_shared<MultiArray<T,Ranges...>>(in.mMa); mMa = std::make_shared<Array<T,Ranges...>>(in.mMa);
mProto = OperationRoot<T,Ranges...>(*mMa,mIndices); mProto = OperationRoot<T,Ranges...>(*mMa,mIndices);
mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices, mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
std::make_tuple(mMa), std::make_tuple(mMa),
@ -103,7 +103,7 @@ namespace CNORXZ
mOp = in.mOp; mOp = in.mOp;
mIndices = in.mIndices; mIndices = in.mIndices;
if(mThreadId != in.mThreadId){ if(mThreadId != in.mThreadId){
mMa = std::make_shared<MultiArray<T,Ranges...>>(in.mMa); mMa = std::make_shared<Array<T,Ranges...>>(in.mMa);
mProto = OperationRoot<T,Ranges...>(*mMa,mIndices); mProto = OperationRoot<T,Ranges...>(*mMa,mIndices);
mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices, mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
std::make_tuple(mMa), std::make_tuple(mMa),
@ -124,7 +124,7 @@ namespace CNORXZ
const std::shared_ptr<typename Ranges::IndexType>&... inds) const std::shared_ptr<typename Ranges::IndexType>&... inds)
: mThreadId(omp_get_thread_num()), mOp(op), : mThreadId(omp_get_thread_num()), mOp(op),
mIndices(inds...), mIndices(inds...),
mMa(std::make_shared<MultiArray<T,Ranges...>>(mkArray<T>(inds->range()...))), mMa(std::make_shared<Array<T,Ranges...>>(mkArray<T>(inds->range()...))),
mProto(OperationRoot<T,Ranges...>(*mMa,inds...)), mProto(OperationRoot<T,Ranges...>(*mMa,inds...)),
mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...), mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )), std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),
@ -137,7 +137,7 @@ namespace CNORXZ
: mThreadId(omp_get_thread_num()), : mThreadId(omp_get_thread_num()),
//mDyn(dyn), //mDyn(dyn),
mOp(op), mIndices(inds...), mOp(op), mIndices(inds...),
mMa(std::make_shared<MultiArray<T,Ranges...>>(mkArray<T>(inds->range()...))), mMa(std::make_shared<Array<T,Ranges...>>(mkArray<T>(inds->range()...))),
mProto(OperationRoot<T,Ranges...>(*mMa,inds...)), mProto(OperationRoot<T,Ranges...>(*mMa,inds...)),
mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...), mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )), std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),

8
src/include/dynamic_operation.h
View file

@ -1,6 +1,6 @@
#ifndef __dynamic_operation_h__ #ifndef __cxz_dynamic_operation_h__
#define __dynamic_operation_h__ #define __cxz_dynamic_operation_h__
#include "base_def.h" #include "base_def.h"
#include "cxz_operation.h" #include "cxz_operation.h"
@ -77,13 +77,13 @@ namespace CNORXZ
Operation mOp; Operation mOp;
//OperationRoot<T,Ranges...> mProto; //OperationRoot<T,Ranges...> mProto;
std::tuple<std::shared_ptr<typename Ranges::IndexType>...> mIndices; std::tuple<std::shared_ptr<typename Ranges::IndexType>...> mIndices;
std::shared_ptr<MultiArray<T,Ranges...>> mMa; std::shared_ptr<Array<T,Ranges...>> mMa;
OpH<OperationRoot<T,Ranges...>> mProto; OpH<OperationRoot<T,Ranges...>> mProto;
typedef ILoop<std::tuple<OperationRoot<T,Ranges...>,Operation>, typedef ILoop<std::tuple<OperationRoot<T,Ranges...>,Operation>,
std::tuple<std::shared_ptr<typename Ranges::IndexType>...>, std::tuple<std::shared_ptr<typename Ranges::IndexType>...>,
std::tuple<std::shared_ptr<MultiArray<T,Ranges...>>>, std::tuple<std::shared_ptr<Array<T,Ranges...>>>,
std::tuple<decltype(mProto.mOp->assign( mOp, mkMIndex(std::shared_ptr<typename Ranges::IndexType>()...) ))>> LoopT; std::tuple<decltype(mProto.mOp->assign( mOp, mkMIndex(std::shared_ptr<typename Ranges::IndexType>()...) ))>> LoopT;

34
src/include/functional_array.cc.h
View file

@ -6,30 +6,30 @@ namespace CNORXZ
/**************************** /****************************
* FunctionalMultiArray * * FunctionalArray *
****************************/ ****************************/
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges, FunctionalArray<T,Function,SRanges...>::FunctionalArray(const std::shared_ptr<SRanges>&... ranges,
const std::shared_ptr<Function>& func) : const std::shared_ptr<Function>& func) :
MultiArrayBase<T,SRanges...>(ranges...), mFunc(func) {} ArrayBase<T,SRanges...>(ranges...), mFunc(func) {}
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges) : FunctionalArray<T,Function,SRanges...>::FunctionalArray(const std::shared_ptr<SRanges>&... ranges) :
MultiArrayBase<T,SRanges...>(ranges...) {} ArrayBase<T,SRanges...>(ranges...) {}
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space) : FunctionalArray<T,Function,SRanges...>::FunctionalArray(const typename CRange::Space& space) :
MultiArrayBase<T,SRanges...>(space) {} ArrayBase<T,SRanges...>(space) {}
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space, FunctionalArray<T,Function,SRanges...>::FunctionalArray(const typename CRange::Space& space,
const std::shared_ptr<Function>& func) : const std::shared_ptr<Function>& func) :
MultiArrayBase<T,SRanges...>(space), mFunc(func) {} ArrayBase<T,SRanges...>(space), mFunc(func) {}
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
const T& FunctionalMultiArray<T,Function,SRanges...>::operator[](const IndexType& i) const const T& FunctionalArray<T,Function,SRanges...>::operator[](const IndexType& i) const
{ {
if constexpr(Function::FISSTATIC){ if constexpr(Function::FISSTATIC){
mVal = Function::apply(i.meta()); mVal = Function::apply(i.meta());
@ -41,7 +41,7 @@ namespace CNORXZ
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
const T& FunctionalMultiArray<T,Function,SRanges...>::at(const typename CRange::IndexType::MetaType& meta) const const T& FunctionalArray<T,Function,SRanges...>::at(const typename CRange::IndexType::MetaType& meta) const
{ {
if constexpr(Function::FISSTATIC){ if constexpr(Function::FISSTATIC){
mVal = Function::apply(meta); mVal = Function::apply(meta);
@ -53,32 +53,32 @@ namespace CNORXZ
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
const T* FunctionalMultiArray<T,Function,SRanges...>::data() const const T* FunctionalArray<T,Function,SRanges...>::data() const
{ {
return &mVal; return &mVal;
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
bool FunctionalMultiArray<T,Function,SRanges...>::isConst() const bool FunctionalArray<T,Function,SRanges...>::isConst() const
{ {
return true; return true;
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
bool FunctionalMultiArray<T,Function,SRanges...>::isSlice() const bool FunctionalArray<T,Function,SRanges...>::isSlice() const
{ {
return false; return false;
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
std::shared_ptr<MultiArrayBase<T,AnonymousRange> > FunctionalMultiArray<T,Function,SRanges...>::anonymous(bool slice) const std::shared_ptr<ArrayBase<T,AnonymousRange> > FunctionalArray<T,Function,SRanges...>::anonymous(bool slice) const
{ {
assert(0); // think about it carefully assert(0); // think about it carefully
return nullptr; return nullptr;
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
ConstOperationRoot<T,SRanges...> FunctionalMultiArray<T,Function,SRanges...>:: ConstOperationRoot<T,SRanges...> FunctionalArray<T,Function,SRanges...>::
operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const operator()(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
{ {
if(not mMaPtr){ if(not mMaPtr){
@ -89,7 +89,7 @@ namespace CNORXZ
} }
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
auto FunctionalMultiArray<T,Function,SRanges...>:: auto FunctionalArray<T,Function,SRanges...>::
exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
-> Operation<T,Function,MetaOperationRoot<SRanges>...> -> Operation<T,Function,MetaOperationRoot<SRanges>...>
{ {

22
src/include/functional_array.h
View file

@ -1,6 +1,6 @@
#ifndef __functional_array__ #ifndef __cxz_functional_array__
#define __functional_array__ #define __cxz_functional_array__
#include "cxz_array_base.h" #include "cxz_array_base.h"
#include "slice.h" #include "slice.h"
@ -9,14 +9,14 @@ namespace CNORXZ
{ {
template <typename T, class Function, class... SRanges> template <typename T, class Function, class... SRanges>
class FunctionalMultiArray : public MultiArrayBase<T,SRanges...> class FunctionalArray : public ArrayBase<T,SRanges...>
{ {
public: public:
typedef ContainerRange<SRanges...> CRange; typedef ContainerRange<SRanges...> CRange;
typedef MultiArrayBase<T,SRanges...> MAB; typedef ArrayBase<T,SRanges...> MAB;
typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType; typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
typedef MultiArray<T,SRanges...> MAType; typedef Array<T,SRanges...> MAType;
typedef T value_type; typedef T value_type;
private: private:
@ -27,11 +27,11 @@ namespace CNORXZ
public: public:
DEFAULT_MEMBERS(FunctionalMultiArray); DEFAULT_MEMBERS(FunctionalArray);
FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges, const std::shared_ptr<Function>& func); FunctionalArray(const std::shared_ptr<SRanges>&... ranges, const std::shared_ptr<Function>& func);
FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges); FunctionalArray(const std::shared_ptr<SRanges>&... ranges);
FunctionalMultiArray(const typename CRange::Space& space); FunctionalArray(const typename CRange::Space& space);
FunctionalMultiArray(const typename CRange::Space& space, const std::shared_ptr<Function>& func); FunctionalArray(const typename CRange::Space& space, const std::shared_ptr<Function>& func);
virtual const T& operator[](const IndexType& i) const override; virtual const T& operator[](const IndexType& i) const override;
virtual const T& at(const typename CRange::IndexType::MetaType& meta) const override; virtual const T& at(const typename CRange::IndexType::MetaType& meta) const override;
@ -40,7 +40,7 @@ namespace CNORXZ
virtual bool isConst() const override; virtual bool isConst() const override;
virtual bool isSlice() const override; virtual bool isSlice() const override;
virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override; virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
auto exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const auto exec(const std::shared_ptr<typename SRanges::IndexType>&... inds) const
-> Operation<T,Function,MetaOperationRoot<SRanges>...>; -> Operation<T,Function,MetaOperationRoot<SRanges>...>;

36
src/include/helper_tools.cc.h
View file

@ -237,7 +237,7 @@ namespace CNORXZ
template <class MArray> template <class MArray>
auto dynamic(const MArray& ma, bool slice) auto dynamic(const MArray& ma, bool slice)
-> std::shared_ptr<MultiArrayBase<typename MArray::value_type,DynamicRange>> -> std::shared_ptr<ArrayBase<typename MArray::value_type,DynamicRange>>
{ {
DynamicRangeFactory drf(ma.range()->space()); DynamicRangeFactory drf(ma.range()->space());
if(slice){ if(slice){
@ -246,7 +246,7 @@ namespace CNORXZ
ma.data() ); ma.data() );
} }
else { else {
return std::make_shared<MultiArray<typename MArray::value_type,DynamicRange>> return std::make_shared<Array<typename MArray::value_type,DynamicRange>>
( std::dynamic_pointer_cast<DynamicRange>( drf.create() ), ( std::dynamic_pointer_cast<DynamicRange>( drf.create() ),
ma.vdata() ); ma.vdata() );
} }
@ -254,7 +254,7 @@ namespace CNORXZ
template <class MArray> template <class MArray>
auto mdynamic(MArray& ma, bool slice) auto mdynamic(MArray& ma, bool slice)
-> std::shared_ptr<MutableMultiArrayBase<typename MArray::value_type,DynamicRange>> -> std::shared_ptr<MutableArrayBase<typename MArray::value_type,DynamicRange>>
{ {
DynamicRangeFactory drf(ma.range()->space()); DynamicRangeFactory drf(ma.range()->space());
if(slice){ if(slice){
@ -263,7 +263,7 @@ namespace CNORXZ
ma.data() ); ma.data() );
} }
else { else {
return std::make_shared<MultiArray<typename MArray::value_type,DynamicRange>> return std::make_shared<Array<typename MArray::value_type,DynamicRange>>
( std::dynamic_pointer_cast<DynamicRange>( drf.create() ), ( std::dynamic_pointer_cast<DynamicRange>( drf.create() ),
ma.vdata() ); ma.vdata() );
} }
@ -294,7 +294,7 @@ namespace CNORXZ
} }
template <typename T, class Range1, class... RangeTypes> template <typename T, class Range1, class... RangeTypes>
auto anonToDynView(const MultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma) auto anonToDynView(const ArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
-> ConstSlice<T,Range1,RangeTypes...,DynamicRange> -> ConstSlice<T,Range1,RangeTypes...,DynamicRange>
{ {
constexpr size_t LAST = sizeof...(RangeTypes)+1; constexpr size_t LAST = sizeof...(RangeTypes)+1;
@ -307,7 +307,7 @@ namespace CNORXZ
} }
template <typename T, class Range1, class... RangeTypes> template <typename T, class Range1, class... RangeTypes>
auto anonToDynView(MutableMultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma) auto anonToDynView(MutableArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
-> Slice<T,Range1,RangeTypes...,DynamicRange> -> Slice<T,Range1,RangeTypes...,DynamicRange>
{ {
constexpr size_t LAST = sizeof...(RangeTypes)+1; constexpr size_t LAST = sizeof...(RangeTypes)+1;
@ -320,8 +320,8 @@ namespace CNORXZ
} }
template <typename T, class Range1, class... RangeTypes> template <typename T, class Range1, class... RangeTypes>
auto dynToAnonMove(MultiArray<T,Range1,RangeTypes...,DynamicRange>&& ma) auto dynToAnonMove(Array<T,Range1,RangeTypes...,DynamicRange>&& ma)
-> MultiArray<T,Range1,RangeTypes...,AnonymousRange> -> Array<T,Range1,RangeTypes...,AnonymousRange>
{ {
constexpr size_t LAST = sizeof...(RangeTypes)+1; constexpr size_t LAST = sizeof...(RangeTypes)+1;
AnonymousRangeFactory arf(rptr<LAST>(ma)->orig()); AnonymousRangeFactory arf(rptr<LAST>(ma)->orig());
@ -333,7 +333,7 @@ namespace CNORXZ
} }
template <typename T> template <typename T>
auto anonToDynView(const MultiArrayBase<T,AnonymousRange>& ma) auto anonToDynView(const ArrayBase<T,AnonymousRange>& ma)
-> ConstSlice<T,DynamicRange> -> ConstSlice<T,DynamicRange>
{ {
DynamicRangeFactory drf(rptr<0>(ma)->orig()); DynamicRangeFactory drf(rptr<0>(ma)->orig());
@ -342,7 +342,7 @@ namespace CNORXZ
} }
template <typename T> template <typename T>
auto anonToDynView(MutableMultiArrayBase<T,AnonymousRange>& ma) auto anonToDynView(MutableArrayBase<T,AnonymousRange>& ma)
-> Slice<T,DynamicRange> -> Slice<T,DynamicRange>
{ {
DynamicRangeFactory drf(rptr<0>(ma)->orig()); DynamicRangeFactory drf(rptr<0>(ma)->orig());
@ -351,8 +351,8 @@ namespace CNORXZ
} }
template <typename T> template <typename T>
auto dynToAnonMove(MultiArray<T,DynamicRange>&& ma) auto dynToAnonMove(Array<T,DynamicRange>&& ma)
-> MultiArray<T,AnonymousRange> -> Array<T,AnonymousRange>
{ {
AnonymousRangeFactory arf(rptr<0>(ma)->orig()); AnonymousRangeFactory arf(rptr<0>(ma)->orig());
auto mNSpace = std::make_tuple( createExplicit( arf ) ); auto mNSpace = std::make_tuple( createExplicit( arf ) );
@ -376,23 +376,23 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
auto mkArray(const std::shared_ptr<Ranges>&... rs) auto mkArray(const std::shared_ptr<Ranges>&... rs)
-> MultiArray<T,Ranges...> -> Array<T,Ranges...>
{ {
return MultiArray<T,Ranges...>(rs...); return Array<T,Ranges...>(rs...);
} }
template <typename T, class... Ranges> template <typename T, class... Ranges>
auto mkArray(const std::shared_ptr<Ranges>&... rs, const T& val) auto mkArray(const std::shared_ptr<Ranges>&... rs, const T& val)
-> MultiArray<T,Ranges...> -> Array<T,Ranges...>
{ {
return MultiArray<T,Ranges...>(rs..., val); return Array<T,Ranges...>(rs..., val);
} }
template <typename T, class... Ranges> template <typename T, class... Ranges>
auto mkArrayPtr(const std::shared_ptr<Ranges>&... rs) auto mkArrayPtr(const std::shared_ptr<Ranges>&... rs)
-> std::shared_ptr<MultiArray<T,Ranges...>> -> std::shared_ptr<Array<T,Ranges...>>
{ {
return std::make_shared<MultiArray<T,Ranges...>>(rs...); return std::make_shared<Array<T,Ranges...>>(rs...);
} }
} }

34
src/include/helper_tools.h
View file

@ -1,6 +1,6 @@
#ifndef __helper_tools_h__ #ifndef __cxz_helper_tools_h__
#define __helper_tools_h__ #define __cxz_helper_tools_h__
#include "base_def.h" #include "base_def.h"
#include "slice.h" #include "slice.h"
@ -119,35 +119,35 @@ namespace CNORXZ
template <class MArray> template <class MArray>
auto dynamic(const MArray& ma, bool slice = false) auto dynamic(const MArray& ma, bool slice = false)
-> std::shared_ptr<MultiArrayBase<typename MArray::value_type,DynamicRange>>; -> std::shared_ptr<ArrayBase<typename MArray::value_type,DynamicRange>>;
template <class MArray> template <class MArray>
auto mdynamic(MArray& ma, bool slice) auto mdynamic(MArray& ma, bool slice)
-> std::shared_ptr<MutableMultiArrayBase<typename MArray::value_type,DynamicRange>>; -> std::shared_ptr<MutableArrayBase<typename MArray::value_type,DynamicRange>>;
template <typename T, class Range1, class... RangeTypes> template <typename T, class Range1, class... RangeTypes>
auto anonToDynView(const MultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma) auto anonToDynView(const ArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
-> ConstSlice<T,Range1,RangeTypes...,DynamicRange>; -> ConstSlice<T,Range1,RangeTypes...,DynamicRange>;
template <typename T, class Range1, class... RangeTypes> template <typename T, class Range1, class... RangeTypes>
auto anonToDynView(MutableMultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma) auto anonToDynView(MutableArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
-> Slice<T,Range1,RangeTypes...,DynamicRange>; -> Slice<T,Range1,RangeTypes...,DynamicRange>;
template <typename T, class Range1, class... RangeTypes> template <typename T, class Range1, class... RangeTypes>
auto dynToAnonMove(MultiArray<T,Range1,RangeTypes...,DynamicRange>&& ma) auto dynToAnonMove(Array<T,Range1,RangeTypes...,DynamicRange>&& ma)
-> MultiArray<T,Range1,RangeTypes...,AnonymousRange>; -> Array<T,Range1,RangeTypes...,AnonymousRange>;
template <typename T> template <typename T>
auto anonToDynView(const MultiArrayBase<T,AnonymousRange>& ma) auto anonToDynView(const ArrayBase<T,AnonymousRange>& ma)
-> ConstSlice<T,DynamicRange>; -> ConstSlice<T,DynamicRange>;
template <typename T> template <typename T>
auto anonToDynView(MutableMultiArrayBase<T,AnonymousRange>& ma) auto anonToDynView(MutableArrayBase<T,AnonymousRange>& ma)
-> Slice<T,DynamicRange>; -> Slice<T,DynamicRange>;
template <typename T> template <typename T>
auto dynToAnonMove(MultiArray<T,DynamicRange>&& ma) auto dynToAnonMove(Array<T,DynamicRange>&& ma)
-> MultiArray<T,AnonymousRange>; -> Array<T,AnonymousRange>;
template <class Range> template <class Range>
auto metaSlice(const std::shared_ptr<Range>& r) auto metaSlice(const std::shared_ptr<Range>& r)
@ -159,15 +159,15 @@ namespace CNORXZ
template <typename T, class... Ranges> template <typename T, class... Ranges>
auto mkArray(const std::shared_ptr<Ranges>&... rs) auto mkArray(const std::shared_ptr<Ranges>&... rs)
-> MultiArray<T,Ranges...>; -> Array<T,Ranges...>;
template <typename T, class... Ranges> template <typename T, class... Ranges>
auto mkArrayPtr(const std::shared_ptr<Ranges>&... rs) auto mkArrayPtr(const std::shared_ptr<Ranges>&... rs)
-> std::shared_ptr<MultiArray<T,Ranges...>>; -> std::shared_ptr<Array<T,Ranges...>>;
template <typename T, class... Ranges> template <typename T, class... Ranges>
auto mkArray(const std::shared_ptr<Ranges>&... rs, const T& val) auto mkArray(const std::shared_ptr<Ranges>&... rs, const T& val)
-> MultiArray<T,Ranges...>; -> Array<T,Ranges...>;
template <class OpTp, class IndTp, class VarTp, class LTp> template <class OpTp, class IndTp, class VarTp, class LTp>
auto mkILoop(const OpTp& opTp, const IndTp& indTp, const VarTp& varTp, const LTp& lTp, auto mkILoop(const OpTp& opTp, const IndTp& indTp, const VarTp& varTp, const LTp& lTp,
@ -214,11 +214,11 @@ namespace CNORXZ
template <class Index> template <class Index>
inline auto mkOp(const std::shared_ptr<Index>& i) inline auto mkOp(const std::shared_ptr<Index>& i)
-> decltype(std::declval<FunctionalMultiArray<typename Index::MetaType, -> decltype(std::declval<FunctionalArray<typename Index::MetaType,
identity<typename Index::MetaType>,typename Index::RangeType> > identity<typename Index::MetaType>,typename Index::RangeType> >
().exec(i)) ().exec(i))
{ {
FunctionalMultiArray<typename Index::MetaType, FunctionalArray<typename Index::MetaType,
identity<typename Index::MetaType>, identity<typename Index::MetaType>,
typename Index::RangeType> fma(i->range()); typename Index::RangeType> fma(i->range());
return fma.exec(i); return fma.exec(i);

4
src/include/high_level_operation.h
View file

@ -1,6 +1,6 @@
#ifndef __high_level_operation_h__ #ifndef __cxz_high_level_operation_h__
#define __high_level_operation_h__ #define __cxz_high_level_operation_h__
#include "base_def.h" #include "base_def.h"
#include "ranges/rheader.h" #include "ranges/rheader.h"

12
src/include/map_range.cc.h
View file

@ -415,7 +415,7 @@ namespace CNORXZ
struct OutRangeMaker<SpaceType::ANY> struct OutRangeMaker<SpaceType::ANY>
{ {
template <class MapF, class ORType> template <class MapF, class ORType>
static void mk(std::shared_ptr<ORType>& outRange, MultiArray<size_t,ORType>& mapMult, const MapF& mapf) static void mk(std::shared_ptr<ORType>& outRange, Array<size_t,ORType>& mapMult, const MapF& mapf)
{ {
std::map<typename MapF::value_type,size_t> mult; std::map<typename MapF::value_type,size_t> mult;
for(auto ii = mapf.begin(); ii.max() != ii.pos(); ++ii) { for(auto ii = mapf.begin(); ii.max() != ii.pos(); ++ii) {
@ -434,7 +434,7 @@ namespace CNORXZ
typename ORType::FType orf(outmeta); typename ORType::FType orf(outmeta);
outRange = std::dynamic_pointer_cast<ORType>( orf.create() ); outRange = std::dynamic_pointer_cast<ORType>( orf.create() );
mapMult = MultiArray<size_t,ORType>( outRange, outmult ); mapMult = Array<size_t,ORType>( outRange, outmult );
} }
}; };
@ -442,7 +442,7 @@ namespace CNORXZ
struct OutRangeMaker<SpaceType::NONE> struct OutRangeMaker<SpaceType::NONE>
{ {
template <class MapF, class ORType> template <class MapF, class ORType>
static void mk(std::shared_ptr<ORType>& outRange, MultiArray<size_t,ORType>& mapMult, const MapF& mapf) static void mk(std::shared_ptr<ORType>& outRange, Array<size_t,ORType>& mapMult, const MapF& mapf)
{ {
static_assert( std::is_same<size_t,typename MapF::value_type>::value, static_assert( std::is_same<size_t,typename MapF::value_type>::value,
"out range value type for NONE must be size_t" ); "out range value type for NONE must be size_t" );
@ -464,7 +464,7 @@ namespace CNORXZ
typename ORType::FType orf(max); typename ORType::FType orf(max);
outRange = std::dynamic_pointer_cast<ORType>( orf.create() ); outRange = std::dynamic_pointer_cast<ORType>( orf.create() );
mapMult = MultiArray<size_t,ORType>( outRange, outmult ); mapMult = Array<size_t,ORType>( outRange, outmult );
} }
}; };
@ -472,7 +472,7 @@ namespace CNORXZ
template <class MA> template <class MA>
void GenMapRange<ORType,Op,XSTYPE,Ranges...>::mkOutRange(const MA& mapf) void GenMapRange<ORType,Op,XSTYPE,Ranges...>::mkOutRange(const MA& mapf)
{ {
//FunctionalMultiArray<typename MapF::value_type,MapF,Ranges...> fma(mSpace, mMapf); //FunctionalArray<typename MapF::value_type,MapF,Ranges...> fma(mSpace, mMapf);
OutRangeMaker<XSTYPE>::mk(mOutRange,mMapMult,mapf); OutRangeMaker<XSTYPE>::mk(mOutRange,mMapMult,mapf);
auto i = mapf.begin(); auto i = mapf.begin();
mMapPos.resize(i.max()); mMapPos.resize(i.max());
@ -666,7 +666,7 @@ namespace CNORXZ
template <class ORType, class Op, SpaceType XSTYPE, class... Ranges> template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
auto GenMapRange<ORType,Op,XSTYPE,Ranges...>::mapMultiplicity() const auto GenMapRange<ORType,Op,XSTYPE,Ranges...>::mapMultiplicity() const
-> const MultiArray<size_t,ORType>& -> const Array<size_t,ORType>&
{ {
return mMapMult; return mMapMult;
} }

14
src/include/map_range.h
View file

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __map_range_h__ #ifndef __cxz_map_range_h__
#define __map_range_h__ #define __cxz_map_range_h__
#include <cstdlib> #include <cstdlib>
#include <tuple> #include <tuple>
@ -29,12 +29,12 @@ namespace CNORXZ
template <class Func, class... Indices> template <class Func, class... Indices>
auto mkMapOp(const std::shared_ptr<Func>& func, auto mkMapOp(const std::shared_ptr<Func>& func,
const std::shared_ptr<Indices>&... is) const std::shared_ptr<Indices>&... is)
-> decltype(std::make_tuple(FunctionalMultiArray<typename Func::value_type,Func, -> decltype(std::make_tuple(FunctionalArray<typename Func::value_type,Func,
typename Indices::RangeType...>().exec(is...), typename Indices::RangeType...>().exec(is...),
FunctionalMultiArray<typename Func::value_type,Func, FunctionalArray<typename Func::value_type,Func,
typename Indices::RangeType...>())) typename Indices::RangeType...>()))
{ {
typedef FunctionalMultiArray<typename Func::value_type,Func,typename Indices::RangeType...> FMA; typedef FunctionalArray<typename Func::value_type,Func,typename Indices::RangeType...> FMA;
if(Func::FISSTATIC){ if(Func::FISSTATIC){
FMA fma(is->range()...); FMA fma(is->range()...);
return std::make_tuple(fma.exec(is...),fma); return std::make_tuple(fma.exec(is...),fma);
@ -277,7 +277,7 @@ namespace CNORXZ
Op mMapf; Op mMapf;
//Op mMapf; //Op mMapf;
std::shared_ptr<ORType> mOutRange; std::shared_ptr<ORType> mOutRange;
MultiArray<size_t,ORType> mMapMult; Array<size_t,ORType> mMapMult;
vector<size_t> mMapPos; vector<size_t> mMapPos;
private: private:
@ -314,7 +314,7 @@ namespace CNORXZ
virtual IndexType begin() const final; virtual IndexType begin() const final;
virtual IndexType end() const final; virtual IndexType end() const final;
const MultiArray<size_t,ORType>& mapMultiplicity() const; const Array<size_t,ORType>& mapMultiplicity() const;
ConstSlice<size_t,GenMapRange> explMapMultiplicity() const; ConstSlice<size_t,GenMapRange> explMapMultiplicity() const;
vector<size_t> mapPos() const; vector<size_t> mapPos() const;

4
src/include/map_range_factory_product_map.h
View file

@ -1,6 +1,6 @@
#ifndef __map_range_factory_product_map_h__ #ifndef __cxz_map_range_factory_product_map_h__
#define __map_range_factory_product_map_h__ #define __cxz_map_range_factory_product_map_h__
#include <memory> #include <memory>
#include <vector> #include <vector>

10
src/include/mbase_def.h
View file

@ -1,6 +1,6 @@
#ifndef __mbase_def_h__ #ifndef __cxz_mbase_def_h__
#define __mbase_def_h__ #define __cxz_mbase_def_h__
#include "ranges/rbase_def.h" #include "ranges/rbase_def.h"
#include "allocator.h" #include "allocator.h"
@ -23,15 +23,15 @@ namespace CNORXZ
// cxz_array.h // cxz_array.h
template <typename T, class... SRanges> template <typename T, class... SRanges>
class MultiArrayBase; class ArrayBase;
// cxz_array.h // cxz_array.h
template <typename T, class... SRanges> template <typename T, class... SRanges>
class MutableMultiArrayBase; class MutableArrayBase;
// cxz_array.h // cxz_array.h
template <typename T, class... SRanges> template <typename T, class... SRanges>
class MultiArray; class Array;
// cxz_operation.h // cxz_operation.h
template <typename T, class OperationClass> template <typename T, class OperationClass>

4
src/include/operation_def.h
View file

@ -1,6 +1,6 @@
#ifndef __operation_def_h__ #ifndef __cxz_operation_def_h__
#define __operation_def_h__ #define __cxz_operation_def_h__
#include "cxz_operation.h" #include "cxz_operation.h"

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

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __anonymous_range_h__ #ifndef __cxz_anonymous_range_h__
#define __anonymous_range_h__ #define __cxz_anonymous_range_h__
#include <cstdlib> #include <cstdlib>
#include <map> #include <map>

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

@ -1,6 +1,6 @@
#ifndef __dynamic_meta_h__ #ifndef __cxz_dynamic_meta_h__
#define __dynamic_meta_h__ #define __cxz_dynamic_meta_h__
#include <cstdlib> #include <cstdlib>
#include <utility> #include <utility>

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

@ -1,6 +1,6 @@
#ifndef __dynamic_range_h__ #ifndef __cxz_dynamic_range_h__
#define __dynamic_range_h__ #define __cxz_dynamic_range_h__
#include <cassert> #include <cassert>
#include <map> #include <map>

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

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __index_base_h__ #ifndef __cxz_index_base_h__
#define __index_base_h__ #define __cxz_index_base_h__
#include <cstdlib> #include <cstdlib>
#include <string> #include <string>

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

@ -1,6 +1,6 @@
#ifndef __index_type_h__ #ifndef __cxz_index_type_h__
#define __index_type_h__ #define __cxz_index_type_h__
namespace CNORXZ namespace CNORXZ
{ {

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

@ -1,6 +1,6 @@
#ifndef __index_wrapper_h__ #ifndef __cxz_index_wrapper_h__
#define __index_wrapper_h__ #define __cxz_index_wrapper_h__
#include "ranges/rbase_def.h" #include "ranges/rbase_def.h"
#include "xfor/xfor.h" #include "xfor/xfor.h"

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

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __multi_range_h__ #ifndef __cxz_multi_range_h__
#define __multi_range_h__ #define __cxz_multi_range_h__
#include <cstdlib> #include <cstdlib>
#include <tuple> #include <tuple>

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

@ -1,6 +1,6 @@
#ifndef __multi_range_factory_product_map_h__ #ifndef __cxz_multi_range_factory_product_map_h__
#define __multi_range_factory_product_map_h__ #define __cxz_multi_range_factory_product_map_h__
#include <memory> #include <memory>
#include <vector> #include <vector>

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

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __range_base_h__ #ifndef __cxz_range_base_h__
#define __range_base_h__ #define __cxz_range_base_h__
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>

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

@ -1,6 +1,6 @@
#ifndef __range_helper_h__ #ifndef __cxz_range_helper_h__
#define __range_helper_h__ #define __cxz_range_helper_h__
namespace CNORXZ namespace CNORXZ
{ {

10
src/include/ranges/range_types/classic_range.h
View file

@ -4,11 +4,11 @@
//#else //#else
#ifndef include_range_type #ifndef include_range_type
#ifdef __ranges_header__ #ifdef __cxz_ranges_header__
// assert, that this is only used within range_types/header.h // assert, that this is only used within range_types/header.h
#ifndef __range_type_classic_def__ #ifndef __cxz_range_type_classic_def__
#define __range_type_classic_def__ #define __cxz_range_type_classic_def__
namespace CNORXZ namespace CNORXZ
{ {
@ -80,8 +80,8 @@ namespace CNORXZ
} }
#endif // #ifndef __range_type_classic_def__ #endif // #ifndef __cxz_range_type_classic_def__
#endif // #ifdef __ranges_header__ #endif // #ifdef __cxz_ranges_header__
#endif // #ifdef include_range_type #endif // #ifdef include_range_type

14
src/include/ranges/range_types/header.h
View file

@ -1,19 +1,19 @@
#ifdef include_range_type #ifdef include_range_type
#define __incl_this__ #define __cxz_incl_this__
#endif #endif
#ifdef __single_range_h__ #ifdef __cxz_single_range_h__
// singel_range is template which is specialized here // singel_range is template which is specialized here
// therefore it must be defined before... // therefore it must be defined before...
#define __incl_this__ #define __cxz_incl_this__
#endif #endif
#ifdef __incl_this__ #ifdef __cxz_incl_this__
#define __ranges_header__ #define __cxz_ranges_header__
//#ifndef __ranges_header__ //#ifndef __cxz_ranges_header__
//#define __ranges_header__ //#define __cxz_ranges_header__
#include "null_range.h" #include "null_range.h"
#include "spin_range.h" #include "spin_range.h"

10
src/include/ranges/range_types/null_range.h
View file

@ -4,11 +4,11 @@
include_range_type(NUL,-2) include_range_type(NUL,-2)
#else #else
#ifdef __ranges_header__ #ifdef __cxz_ranges_header__
// assert, that this is only used within range_types/header.h // assert, that this is only used within range_types/header.h
#ifndef __range_type_null_def__ #ifndef __cxz_range_type_null_def__
#define __range_type_null_def__ #define __cxz_range_type_null_def__
namespace CNORXZ namespace CNORXZ
{ {
@ -89,8 +89,8 @@ namespace CNORXZ
} }
#endif // #ifndef __range_type_null_def__ #endif // #ifndef __cxz_range_type_null_def__
#endif // #ifdef __ranges_header__ #endif // #ifdef __cxz_ranges_header__
#endif // #ifdef include_range_type #endif // #ifdef include_range_type

10
src/include/ranges/range_types/space_range.h
View file

@ -3,10 +3,10 @@
include_range_type(PSPACE,3) // Periodic 1dim space include_range_type(PSPACE,3) // Periodic 1dim space
#else #else
#ifdef __ranges_header__ #ifdef __cxz_ranges_header__
#ifndef __range_type_space_def__ #ifndef __cxz_range_type_space_def__
#define __range_type_space_def__ #define __cxz_range_type_space_def__
namespace CNORXZ namespace CNORXZ
{ {
@ -128,8 +128,8 @@ namespace CNORXZ
using MSpaceRF = decltype(CreateNDimSpaceRange<N>::template mkf<SpaceRange>()); using MSpaceRF = decltype(CreateNDimSpaceRange<N>::template mkf<SpaceRange>());
} }
#endif // #ifndef __range_type_space_def__ #endif // #ifndef __cxz_range_type_space_def__
#endif // #ifdef __ranges_header__ #endif // #ifdef __cxz_ranges_header__
#endif // #ifdef include_range_type #endif // #ifdef include_range_type

10
src/include/ranges/range_types/spin_range.h
View file

@ -4,11 +4,11 @@
include_range_type(SPIN,2) include_range_type(SPIN,2)
#else #else
#ifdef __ranges_header__ #ifdef __cxz_ranges_header__
// assert, that this is only used within range_types/header.h // assert, that this is only used within range_types/header.h
#ifndef __range_type_spin_def__ #ifndef __cxz_range_type_spin_def__
#define __range_type_spin_def__ #define __cxz_range_type_spin_def__
namespace CNORXZ namespace CNORXZ
{ {
@ -82,8 +82,8 @@ namespace CNORXZ
} }
#endif // #ifndef __range_type_spin_def__ #endif // #ifndef __cxz_range_type_spin_def__
#endif // #ifdef __ranges_header__ #endif // #ifdef __cxz_ranges_header__
#endif // #ifdef include_range_type #endif // #ifdef include_range_type

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

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __ranges_base_def_h__ #ifndef __cxz_ranges_base_def_h__
#define __ranges_base_def_h__ #define __cxz_ranges_base_def_h__
#include <cstdlib> #include <cstdlib>

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

@ -1,6 +1,6 @@
#ifndef __reg_ind_num_h__ #ifndef __cxz_reg_ind_num_h__
#define __reg_ind_num_h__ #define __cxz_reg_ind_num_h__

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

@ -1,6 +1,6 @@
//#ifndef __rheader_h__ //#ifndef __cxz_rheader_h__
//#define __rheader_h__ //#define __cxz_rheader_h__
#include "dynamic_range.h" #include "dynamic_range.h"
#include "rpheader.h" #include "rpheader.h"

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

@ -1,6 +1,6 @@
//#ifndef __rpheader_h__ //#ifndef __cxz_rpheader_h__
//#define __rpheader_h__ //#define __cxz_rpheader_h__
#include "single_range.h" #include "single_range.h"
#include "multi_range.h" #include "multi_range.h"

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

@ -1,7 +1,7 @@
// -*- C++ -*- // -*- C++ -*-
#ifndef __single_range_h__ #ifndef __cxz_single_range_h__
#define __single_range_h__ #define __cxz_single_range_h__
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>

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

@ -1,6 +1,6 @@
#ifndef __subrange_h__ #ifndef __cxz_subrange_h__
#define __subrange_h__ #define __cxz_subrange_h__
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>

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

@ -1,6 +1,6 @@
#ifndef __ma_type_map_h__ #ifndef __cxz_type_map_h__
#define __ma_type_map_h__ #define __cxz_type_map_h__
#include <string> #include <string>
#include <vector> #include <vector>

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

@ -1,6 +1,6 @@
#ifndef __value_range_h__ #ifndef __cxz_value_range_h__
#define __value_range_h__ #define __cxz_value_range_h__
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>

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

@ -1,6 +1,6 @@
#ifndef __x_to_string_h__ #ifndef __cxz_x_to_string_h__
#define __x_to_string_h__ #define __cxz_x_to_string_h__
#include <string> #include <string>
#include <vector> #include <vector>

18
src/include/slice.cc.h
View file

@ -17,7 +17,7 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstSlice<T,SRanges...>::ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges, ConstSlice<T,SRanges...>::ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
const T* data) : const T* data) :
MultiArrayBase<T,SRanges...>(ranges), ArrayBase<T,SRanges...>(ranges),
mData(data) mData(data)
{ {
MAB::mInit = true; MAB::mInit = true;
@ -25,15 +25,15 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstSlice<T,SRanges...>::ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data) : ConstSlice<T,SRanges...>::ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data) :
MultiArrayBase<T,SRanges...>(ranges...), ArrayBase<T,SRanges...>(ranges...),
mData(data) mData(data)
{ {
MAB::mInit = true; MAB::mInit = true;
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
ConstSlice<T,SRanges...>::ConstSlice(const MultiArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes) : ConstSlice<T,SRanges...>::ConstSlice(const ArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes) :
MultiArrayBase<T,SRanges...> ArrayBase<T,SRanges...>
( ma.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ), ( ma.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ),
mData( ma.data() ) mData( ma.data() )
{ {
@ -87,7 +87,7 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
std::shared_ptr<MultiArrayBase<T,AnonymousRange> > ConstSlice<T,SRanges...>::anonymous(bool slice) const std::shared_ptr<ArrayBase<T,AnonymousRange> > ConstSlice<T,SRanges...>::anonymous(bool slice) const
{ {
assert(slice); assert(slice);
assert(not MAB::mProtoI->sliceMode()); // only originally ordered slices! assert(not MAB::mProtoI->sliceMode()); // only originally ordered slices!
@ -118,13 +118,13 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
Slice<T,SRanges...>::Slice(const std::shared_ptr<SRanges>&... ranges, T* data) : Slice<T,SRanges...>::Slice(const std::shared_ptr<SRanges>&... ranges, T* data) :
MutableMultiArrayBase<T,SRanges...>(ranges...), MutableArrayBase<T,SRanges...>(ranges...),
mData(data) {} mData(data) {}
template <typename T, class... SRanges> template <typename T, class... SRanges>
Slice<T,SRanges...>::Slice(const std::tuple<std::shared_ptr<SRanges>...>& ranges, Slice<T,SRanges...>::Slice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
T* data) : T* data) :
MutableMultiArrayBase<T,SRanges...>(ranges), MutableArrayBase<T,SRanges...>(ranges),
mData(data) mData(data)
{ {
MAB::mInit = true; MAB::mInit = true;
@ -208,14 +208,14 @@ namespace CNORXZ
} }
template <typename T, class... SRanges> template <typename T, class... SRanges>
std::shared_ptr<MultiArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymous(bool slice) const std::shared_ptr<ArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymous(bool slice) const
{ {
assert(0); // think about carefully!!!! assert(0); // think about carefully!!!!
return nullptr; return nullptr;
} }
/* /*
template <typename T, class... SRanges> template <typename T, class... SRanges>
std::shared_ptr<MultiArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymousMove() std::shared_ptr<ArrayBase<T,AnonymousRange> > Slice<T,SRanges...>::anonymousMove()
{ {
assert(0); // think about carefully!!!! assert(0); // think about carefully!!!!
return nullptr; return nullptr;

32
src/include/slice.h
View file

@ -1,6 +1,6 @@
#ifndef __slice_h__ #ifndef __cxz_slice_h__
#define __slice_h__ #define __cxz_slice_h__
#include "cxz_array_base.h" #include "cxz_array_base.h"
#include "cxz_operation.h" #include "cxz_operation.h"
@ -8,23 +8,23 @@
namespace CNORXZ namespace CNORXZ
{ {
template <typename T, class... SRanges> template <typename T, class... SRanges>
class ConstSlice : public MultiArrayBase<T,SRanges...> class ConstSlice : public ArrayBase<T,SRanges...>
{ {
public: public:
typedef ContainerRange<SRanges...> CRange; typedef ContainerRange<SRanges...> CRange;
typedef MultiArrayBase<T,SRanges...> MAB; typedef ArrayBase<T,SRanges...> MAB;
typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType; typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
using MultiArrayBase<T,SRanges...>::operator(); using ArrayBase<T,SRanges...>::operator();
using MultiArrayBase<T,SRanges...>::operator[]; using ArrayBase<T,SRanges...>::operator[];
DEFAULT_MEMBERS(ConstSlice); DEFAULT_MEMBERS(ConstSlice);
ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges, ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
const T* data = nullptr); const T* data = nullptr);
ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data = nullptr); ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data = nullptr);
ConstSlice(const MultiArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes); ConstSlice(const ArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes);
virtual const T& operator[](const IType& i) const final; virtual const T& operator[](const IType& i) const final;
virtual const T& at(const typename IType::MetaType& meta) const override; virtual const T& at(const typename IType::MetaType& meta) const override;
@ -36,7 +36,7 @@ namespace CNORXZ
virtual auto begin() const -> IType override; virtual auto begin() const -> IType override;
virtual auto end() const -> IType override; virtual auto end() const -> IType override;
virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override; virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds) auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
-> ConstSliceDef<T,SRanges...>; -> ConstSliceDef<T,SRanges...>;
@ -51,18 +51,18 @@ namespace CNORXZ
template <typename T, class... SRanges> template <typename T, class... SRanges>
class Slice : public MutableMultiArrayBase<T,SRanges...> class Slice : public MutableArrayBase<T,SRanges...>
{ {
public: public:
typedef ContainerRange<SRanges...> CRange; typedef ContainerRange<SRanges...> CRange;
typedef MultiArrayBase<T,SRanges...> MAB; typedef ArrayBase<T,SRanges...> MAB;
typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType; typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
using MultiArrayBase<T,SRanges...>::operator(); using ArrayBase<T,SRanges...>::operator();
using MutableMultiArrayBase<T,SRanges...>::operator(); using MutableArrayBase<T,SRanges...>::operator();
using MultiArrayBase<T,SRanges...>::operator[]; using ArrayBase<T,SRanges...>::operator[];
using MutableMultiArrayBase<T,SRanges...>::operator[]; using MutableArrayBase<T,SRanges...>::operator[];
DEFAULT_MEMBERS(Slice); DEFAULT_MEMBERS(Slice);
@ -85,8 +85,8 @@ namespace CNORXZ
virtual auto begin() const -> IType override; virtual auto begin() const -> IType override;
virtual auto end() const -> IType override; virtual auto end() const -> IType override;
virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override; virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
//virtual std::shared_ptr<MultiArrayBase<T,AnonymousRange> > anonymousMove() override; //virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymousMove() override;
auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds) auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
-> SliceDef<T,SRanges...>; -> SliceDef<T,SRanges...>;

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

@ -1,6 +1,6 @@
#ifndef __static_for_h__ #ifndef __cxz_static_for_h__
#define __static_for_h__ #define __cxz_static_for_h__
#include <cstdlib> #include <cstdlib>

8
src/include/statics/traits.h
View file

@ -14,10 +14,10 @@ namespace CNORXZ
static constexpr bool VALUE = true; \ static constexpr bool VALUE = true; \
} }
add_array_trait(MultiArrayBase); add_array_trait(ArrayBase);
add_array_trait(MutableMultiArrayBase); add_array_trait(MutableArrayBase);
add_array_trait(MultiArray); add_array_trait(Array);
add_array_trait(FunctionalMultiArray); add_array_trait(FunctionalArray);
add_array_trait(Slice); add_array_trait(Slice);
add_array_trait(ConstSlice); add_array_trait(ConstSlice);

12
src/include/type_operations.h
View file

@ -1,6 +1,6 @@
#ifndef __type_operations_h__ #ifndef __cxz_type_operations_h__
#define __type_operations_h__ #define __cxz_type_operations_h__
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>
@ -20,7 +20,7 @@ namespace CNORXZ
using namespace CNORXZInternal; using namespace CNORXZInternal;
} }
// MultiArray // Array
template <typename T, class... Ranges> template <typename T, class... Ranges>
class operate class operate
@ -30,7 +30,7 @@ namespace CNORXZ
operate(const std::shared_ptr<typename Ranges::IndexType>&... inds) : ituple(inds...) {} operate(const std::shared_ptr<typename Ranges::IndexType>&... inds) : ituple(inds...) {}
inline auto apply(const MultiArray<T,Ranges...>& ma) inline auto apply(const Array<T,Ranges...>& ma)
-> OperationRoot<T,Ranges...> -> OperationRoot<T,Ranges...>
{ {
return unpack<0,sizeof...(Ranges),0> return unpack<0,sizeof...(Ranges),0>
@ -46,9 +46,9 @@ namespace CNORXZ
}; };
template <class OperationClass, typename T, class... Ranges> template <class OperationClass, typename T, class... Ranges>
class OperationTemplate<MultiArray<T,Ranges...>,OperationClass> : public OperationBase<MultiArray<T,Ranges...>,OperationClass> class OperationTemplate<Array<T,Ranges...>,OperationClass> : public OperationBase<Array<T,Ranges...>,OperationClass>
{ {
typedef OperationBase<MultiArray<T,Ranges...>,OperationClass> OB; typedef OperationBase<Array<T,Ranges...>,OperationClass> OB;
auto operator()(const std::shared_ptr<typename Ranges::IndexType>&... indices) auto operator()(const std::shared_ptr<typename Ranges::IndexType>&... indices)
-> Operation<OperationRoot<T,Ranges...>,operate<T,Ranges...>,OperationClass> -> Operation<OperationRoot<T,Ranges...>,operate<T,Ranges...>,OperationClass>

4
src/include/xfor/exttype.h
View file

@ -1,6 +1,6 @@
#ifndef __exttype_h__ #ifndef __cxz_exttype_h__
#define __exttype_h__ #define __cxz_exttype_h__
#include <array> #include <array>

4
src/include/xfor/for_type.h
View file

@ -1,6 +1,6 @@
#ifndef __for_type_h__ #ifndef __cxz_for_type_h__
#define __for_type_h__ #define __cxz_for_type_h__
namespace CNORXZInternal namespace CNORXZInternal
{ {

4
src/include/xfor/for_utils.h
View file

@ -1,6 +1,6 @@
#ifndef __for_utils_h__ #ifndef __cxz_for_utils_h__
#define __for_utils_h__ #define __cxz_for_utils_h__
//#include "ranges/rheader.h" //#include "ranges/rheader.h"
#include <array> #include <array>

4
src/include/xfor/iloop.h
View file

@ -1,6 +1,6 @@
#ifndef __ma_iloop_h__ #ifndef __cxz_iloop_h__
#define __ma_iloop_h__ #define __cxz_iloop_h__
#include <cstdlib> #include <cstdlib>
#include <memory> #include <memory>

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

@ -1,6 +1,6 @@
#ifndef __xfor_h__ #ifndef __cxz_xfor_h__
#define __xfor_h__ #define __cxz_xfor_h__
#include <cstdlib> #include <cstdlib>
#include <memory> #include <memory>

2
src/lib/ranges/anonymous_range.cc
View file

@ -1,7 +1,7 @@
#include "ranges/anonymous_range.h" #include "ranges/anonymous_range.h"
#include "ranges/ranges_header.cc.h" #include "ranges/ranges_header.cc.h"
#include "ma_assert.h" #include "cxz_assert.h"
namespace CNORXZ namespace CNORXZ
{ {

2
src/lib/ranges/dynamic_range.cc
View file

@ -1,7 +1,7 @@
#include "ranges/dynamic_range.h" #include "ranges/dynamic_range.h"
#include "ranges/ranges_header.cc.h" #include "ranges/ranges_header.cc.h"
#include "ma_assert.h" #include "cxz_assert.h"
namespace CNORXZ namespace CNORXZ
{ {

4
src/tests/CMakeLists.txt
View file

@ -10,8 +10,8 @@ add_dependencies(autest multiarray)
target_link_libraries(autest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray) target_link_libraries(autest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
add_test(NAME autest COMMAND autest) add_test(NAME autest COMMAND autest)
#add_executable(mautest src/tests/ma_unit_test.cc ${MA_CC_FILES}) #add_executable(mautest src/tests/array_unit_test.cc ${MA_CC_FILES})
add_executable(mautest ma_unit_test.cc) add_executable(mautest array_unit_test.cc)
add_dependencies(mautest multiarray) add_dependencies(mautest multiarray)
target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray) target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
add_test(NAME mautest COMMAND mautest) add_test(NAME mautest COMMAND mautest)

12
src/tests/ma_unit_test.cc → src/tests/array_unit_test.cc
View file

@ -98,7 +98,7 @@ namespace {
TEST_F(MATest_1Dim, SimpleCall) TEST_F(MATest_1Dim, SimpleCall)
{ {
MultiArray<double,MATest_1Dim::SRange> ma(srptr, vv); Array<double,MATest_1Dim::SRange> ma(srptr, vv);
EXPECT_EQ( ma.size(), 5u); EXPECT_EQ( ma.size(), 5u);
EXPECT_EQ( ma.isConst(), false); EXPECT_EQ( ma.isConst(), false);
EXPECT_EQ( ma.isSlice(), false); EXPECT_EQ( ma.isSlice(), false);
@ -115,7 +115,7 @@ namespace {
TEST_F(MATest_1Dim, ForLoop) TEST_F(MATest_1Dim, ForLoop)
{ {
vector<double> v2 = { 0.693 , 2.718, 3.141, 1.618, 9.98 }; vector<double> v2 = { 0.693 , 2.718, 3.141, 1.618, 9.98 };
MultiArray<double,MATest_1Dim::SRange> ma(srptr, std::move( v2 ) ); Array<double,MATest_1Dim::SRange> ma(srptr, std::move( v2 ) );
size_t cnt = 0; size_t cnt = 0;
for(auto el: ma){ for(auto el: ma){
@ -142,7 +142,7 @@ namespace {
swapFactory<SRF>( rfbptr, { 'a', 'c', 'e', 'g', 'i' } ); swapFactory<SRF>( rfbptr, { 'a', 'c', 'e', 'g', 'i' } );
std::shared_ptr<SRange> sr2 = std::dynamic_pointer_cast<SRange>( rfbptr->create() ); std::shared_ptr<SRange> sr2 = std::dynamic_pointer_cast<SRange>( rfbptr->create() );
MultiArray<double,MATest_1Dim::SRange> ma(srptr, vv); Array<double,MATest_1Dim::SRange> ma(srptr, vv);
auto i = ma.cbegin(); auto i = ma.cbegin();
EXPECT_EQ( ma[ i.at('x') ], 3.141); EXPECT_EQ( ma[ i.at('x') ], 3.141);
@ -158,7 +158,7 @@ namespace {
TEST_F(MATest_MDim, SimpleCall) TEST_F(MATest_MDim, SimpleCall)
{ {
MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv); Array<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
EXPECT_EQ( ma.size(), 24u ); EXPECT_EQ( ma.size(), 24u );
EXPECT_EQ( ma.range()->dim(), 2u ); EXPECT_EQ( ma.range()->dim(), 2u );
@ -175,7 +175,7 @@ namespace {
TEST_F(MATest_MDim, ReFormat) TEST_F(MATest_MDim, ReFormat)
{ {
MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv); Array<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
auto ma2 = ma.format( sr4ptr ); auto ma2 = ma.format( sr4ptr );
auto i = ma2.cbegin(); auto i = ma2.cbegin();
@ -188,7 +188,7 @@ namespace {
TEST_F(MATest_MDim, SliceTest1) TEST_F(MATest_MDim, SliceTest1)
{ {
MultiArray<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv); Array<double,MATest_MDim::MRange,MATest_MDim::SRange> ma(mrptr, sr3ptr, vv);
Slice<double,MATest_MDim::SRange> sl(sr3ptr); Slice<double,MATest_MDim::SRange> sl(sr3ptr);
auto i = MAT::getIndex(sr3ptr); auto i = MAT::getIndex(sr3ptr);

24
src/tests/op2_unit_test.cc
View file

@ -119,7 +119,7 @@ namespace
TEST_F(MapTest, Exec1) TEST_F(MapTest, Exec1)
{ {
MultiArray<double,SRange,SRange> ma1(sr1ptr,sr2ptr,v1); Array<double,SRange,SRange> ma1(sr1ptr,sr2ptr,v1);
auto ii1 = getIndex( rptr<0>( ma1 ) ); auto ii1 = getIndex( rptr<0>( ma1 ) );
@ -127,8 +127,8 @@ namespace
auto mr = mkMapR( mkMapOp(std::make_shared<plus<size_t>>(),ii1,ii2) , sr1ptr, sr2ptr ); auto mr = mkMapR( mkMapOp(std::make_shared<plus<size_t>>(),ii1,ii2) , sr1ptr, sr2ptr );
//auto mr = mkMapR(std::make_shared<plus<size_t>>(),sr1ptr,sr2ptr); //auto mr = mkMapR(std::make_shared<plus<size_t>>(),sr1ptr,sr2ptr);
MultiArray<double,MpRange> res(mr); Array<double,MpRange> res(mr);
MultiArray<double,MpRange> res2(mr); Array<double,MpRange> res2(mr);
auto jj = getIndex( mr ); auto jj = getIndex( mr );
(*jj)(ii1,ii2); (*jj)(ii1,ii2);
///auto jj = mkMapI( std::make_shared<plus<size_t> >(), ii1, ii1 ); ///auto jj = mkMapI( std::make_shared<plus<size_t> >(), ii1, ii1 );
@ -137,8 +137,8 @@ namespace
auto mult = mr->explMapMultiplicity(); auto mult = mr->explMapMultiplicity();
res2(jj) += ma1(ii1,ii2) / staticcast<double>( mult(jj) ); res2(jj) += ma1(ii1,ii2) / staticcast<double>( mult(jj) );
MultiArray<double,TRange> form = res.format(mpr1ptr->outRange()); Array<double,TRange> form = res.format(mpr1ptr->outRange());
MultiArray<double,TRange> form2 = res2.format(mpr1ptr->outRange()); Array<double,TRange> form2 = res2.format(mpr1ptr->outRange());
EXPECT_EQ( jj->range()->outRange()->size(), static_cast<size_t>( 10 ) ); EXPECT_EQ( jj->range()->outRange()->size(), static_cast<size_t>( 10 ) );
EXPECT_EQ( jj->range()->mapMultiplicity().at(9), static_cast<size_t>( 3 ) ); EXPECT_EQ( jj->range()->mapMultiplicity().at(9), static_cast<size_t>( 3 ) );
@ -169,7 +169,7 @@ namespace
TEST_F(MetaOp_Test, SimpleCall) TEST_F(MetaOp_Test, SimpleCall)
{ {
FunctionalMultiArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr); FunctionalArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
auto i = fma.begin(); auto i = fma.begin();
@ -178,8 +178,8 @@ namespace
TEST_F(MetaOp_Test, Operation) TEST_F(MetaOp_Test, Operation)
{ {
FunctionalMultiArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr); FunctionalArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
MultiArray<double,SR> res( sr1ptr ); Array<double,SR> res( sr1ptr );
auto i1 = MAT::getIndex(sr1ptr); auto i1 = MAT::getIndex(sr1ptr);
auto i2 = MAT::getIndex(sr2ptr); auto i2 = MAT::getIndex(sr2ptr);
@ -203,14 +203,14 @@ namespace
TEST_F(OpTest_Sub, Exec) TEST_F(OpTest_Sub, Exec)
{ {
MultiArray<double,SRange,SRange,SRange> ma1(sr1ptr, sr2ptr, sr3ptr, v1); Array<double,SRange,SRange,SRange> ma1(sr1ptr, sr2ptr, sr3ptr, v1);
MultiArray<double,SRange,SRange> ma2(sr3ptr, sr2ptr, v2); Array<double,SRange,SRange> ma2(sr3ptr, sr2ptr, v2);
SubRangeFactory<SRange> subf(sr2ptr, vector<size_t>({0,2})); SubRangeFactory<SRange> subf(sr2ptr, vector<size_t>({0,2}));
auto subptr = MAT::createExplicit(subf); auto subptr = MAT::createExplicit(subf);
MultiArray<double,SRange,SRange> res(sr3ptr,sr1ptr,0.); Array<double,SRange,SRange> res(sr3ptr,sr1ptr,0.);
MultiArray<double,SRange,SubRange<SRange>,SRange> res2(sr3ptr,subptr,sr1ptr,0.); Array<double,SRange,SubRange<SRange>,SRange> res2(sr3ptr,subptr,sr1ptr,0.);
auto i1 = MAT::getIndex( sr1ptr ); auto i1 = MAT::getIndex( sr1ptr );
auto i2 = MAT::getIndex( sr2ptr ); auto i2 = MAT::getIndex( sr2ptr );

8
src/tests/op3_unit_test.cc
View file

@ -31,9 +31,9 @@ namespace
TEST_F(OpTest_Spin, Contract) TEST_F(OpTest_Spin, Contract)
{ {
MultiArray<double,SR,SR,SR,SR,SR,SR,SR,SR> ma(sr, sr, sr, sr, sr, sr, sr, sr, data); Array<double,SR,SR,SR,SR,SR,SR,SR,SR> ma(sr, sr, sr, sr, sr, sr, sr, sr, data);
MultiArray<double,SR,SR> res1( sr, sr ); Array<double,SR,SR> res1( sr, sr );
MultiArray<double,SR,SR> res2( sr, sr ); Array<double,SR,SR> res2( sr, sr );
auto alpha = MAT::getIndex<SR>(); auto alpha = MAT::getIndex<SR>();
auto beta = MAT::getIndex<SR>(); auto beta = MAT::getIndex<SR>();
@ -47,7 +47,7 @@ namespace
res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix); res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
//res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap); //res1(delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap);
std::clock_t end = std::clock(); std::clock_t end = std::clock();
std::cout << "MultiArray time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC std::cout << "Array time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
<< std::endl; << std::endl;
res2(delta, deltap).par() += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(alpha).c(beta).c(gamma); res2(delta, deltap).par() += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(alpha).c(beta).c(gamma);

12
src/tests/op4_unit_test.cc
View file

@ -43,13 +43,13 @@ namespace
{ {
protected: protected:
MultiArray<double,CR,DR> ma1; Array<double,CR,DR> ma1;
MultiArray<double,CR,DR> ma2; Array<double,CR,DR> ma2;
MultiArray<double,DR> ma3; Array<double,DR> ma3;
MultiArray<double,DR> ma5; Array<double,DR> ma5;
MultiArray<double,CR,DR> res1; Array<double,CR,DR> res1;
MultiArray<double,CR,DR> res2; Array<double,CR,DR> res2;
std::map<std::string,std::shared_ptr<IndexW>> imap; std::map<std::string,std::shared_ptr<IndexW>> imap;

14
src/tests/op_perf_test.cc
View file

@ -165,8 +165,8 @@ namespace {
void OpTest_Spin::contract() void OpTest_Spin::contract()
{ {
MultiArray<double,SR,SR,SR,SR,SR,SR,SR,SR> ma( sr, sr, sr, sr, sr, sr, sr, sr, data); Array<double,SR,SR,SR,SR,SR,SR,SR,SR> ma( sr, sr, sr, sr, sr, sr, sr, sr, data);
MultiArray<double,CR,SR,SR> res1( cr, sr, sr ); Array<double,CR,SR,SR> res1( cr, sr, sr );
auto ii = MAT::getIndex<CR>(cr); auto ii = MAT::getIndex<CR>(cr);
auto jj = MAT::getIndex<CR>(cr); auto jj = MAT::getIndex<CR>(cr);
@ -221,7 +221,7 @@ namespace {
//tcast<v256>(res1)(ii ,delta, deltap).par() += tcast<v256>(ma)(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix); //tcast<v256>(res1)(ii ,delta, deltap).par() += tcast<v256>(ma)(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
//} //}
auto end = std::chrono::system_clock::now(); auto end = std::chrono::system_clock::now();
std::cout << "MultiArray time: " << std::chrono::duration<double>(end-begin).count() std::cout << "Array time: " << std::chrono::duration<double>(end-begin).count()
<< std::endl; << std::endl;
assert( xround(res1.at(mkts(0,0,0))) == xround(vres[0]) ); assert( xround(res1.at(mkts(0,0,0))) == xround(vres[0]) );
@ -251,9 +251,9 @@ namespace {
#ifndef ONLY_SPIN #ifndef ONLY_SPIN
void OpTest_Performance::PCheck() void OpTest_Performance::PCheck()
{ {
MultiArray<double,MRange> ma2(mrptr, cv2); Array<double,MRange> ma2(mrptr, cv2);
MultiArray<double,SRange> ma1(sr1ptr, cv1); Array<double,SRange> ma1(sr1ptr, cv1);
MultiArray<double,MRange> res(mrptr); Array<double,MRange> res(mrptr);
auto si1 = MAT::getIndex(sr1ptr); auto si1 = MAT::getIndex(sr1ptr);
auto si2 = MAT::getIndex(sr2ptr); auto si2 = MAT::getIndex(sr2ptr);
@ -265,7 +265,7 @@ namespace {
res(mi) = ma2(mi) * ma1(si1); res(mi) = ma2(mi) * ma1(si1);
std::clock_t end = std::clock(); std::clock_t end = std::clock();
std::cout << "MultiArray time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC std::cout << "Array time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
<< std::endl; << std::endl;
vector<double> res2(vs1*vs2); vector<double> res2(vs1*vs2);

76
src/tests/op_unit_test.cc
View file

@ -35,7 +35,7 @@ namespace
typedef MRF::oType MRange; typedef MRF::oType MRange;
typedef AnonymousRange ANO; typedef AnonymousRange ANO;
typedef MultiArray<double,ANO> AMA; typedef Array<double,ANO> AMA;
OpTest_MDim() OpTest_MDim()
{ {
@ -77,9 +77,9 @@ namespace
TEST_F(OpTest_1Dim, ExecOp) TEST_F(OpTest_1Dim, ExecOp)
{ {
MultiArray<double,SRange> ma1(srptr, v1); Array<double,SRange> ma1(srptr, v1);
MultiArray<double,SRange> ma2(srptr, v2); Array<double,SRange> ma2(srptr, v2);
MultiArray<double,SRange> res(srptr); Array<double,SRange> res(srptr);
auto i = MAT::getIndex( srptr ); auto i = MAT::getIndex( srptr );
@ -94,10 +94,10 @@ namespace
TEST_F(OpTest_MDim, ExecOp1) TEST_F(OpTest_MDim, ExecOp1)
{ {
MultiArray<double,SRange,SRange> res(sr2ptr,sr4ptr); Array<double,SRange,SRange> res(sr2ptr,sr4ptr);
MultiArray<double,SRange,SRange> res2(sr2ptr,sr4ptr); Array<double,SRange,SRange> res2(sr2ptr,sr4ptr);
const MultiArray<double,SRange> ma1(sr2ptr, v1); const Array<double,SRange> ma1(sr2ptr, v1);
const MultiArray<double,SRange> ma2(sr4ptr, v2); const Array<double,SRange> ma2(sr4ptr, v2);
auto i1 = MAT::getIndex( sr2ptr ); auto i1 = MAT::getIndex( sr2ptr );
auto i2 = MAT::getIndex( sr4ptr ); auto i2 = MAT::getIndex( sr4ptr );
@ -127,9 +127,9 @@ namespace
TEST_F(OpTest_MDim, ExecContract) TEST_F(OpTest_MDim, ExecContract)
{ {
MultiArray<double,SRange> res(sr2ptr); Array<double,SRange> res(sr2ptr);
const MultiArray<double,SRange> ma1(sr2ptr, v1); const Array<double,SRange> ma1(sr2ptr, v1);
const MultiArray<double,SRange> ma2(sr4ptr, v2); const Array<double,SRange> ma2(sr4ptr, v2);
auto i1 = MAT::getIndex( sr2ptr ); auto i1 = MAT::getIndex( sr2ptr );
auto i2 = MAT::getIndex( sr4ptr ); auto i2 = MAT::getIndex( sr4ptr );
@ -143,10 +143,10 @@ namespace
TEST_F(OpTest_MDim, ExecOp2) TEST_F(OpTest_MDim, ExecOp2)
{ {
MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr); Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
MultiArray<double,MRange> ma1(mr1ptr, v3); Array<double,MRange> ma1(mr1ptr, v3);
MultiArray<double,SRange> ma2(sr4ptr, v2); Array<double,SRange> ma2(sr4ptr, v2);
MultiArray<double,SRange> ma3(sr4ptr, v4); Array<double,SRange> ma3(sr4ptr, v4);
auto i1 = MAT::getIndex( mr1ptr ); auto i1 = MAT::getIndex( mr1ptr );
auto i2 = MAT::getIndex( sr4ptr ); auto i2 = MAT::getIndex( sr4ptr );
@ -171,10 +171,10 @@ namespace
TEST_F(OpTest_MDim, ExecOpAnon) TEST_F(OpTest_MDim, ExecOpAnon)
{ {
MultiArray<double,MRange> ma1(mr1ptr, v3); Array<double,MRange> ma1(mr1ptr, v3);
MultiArray<double,AnonymousRange> maa Array<double,AnonymousRange> maa
= *std::dynamic_pointer_cast<MultiArray<double,AnonymousRange>>( ma1.anonymous() ); = *std::dynamic_pointer_cast<Array<double,AnonymousRange>>( ma1.anonymous() );
MultiArray<double,AnonymousRange> maa2( maa.template getRangePtr<0>() ); Array<double,AnonymousRange> maa2( maa.template getRangePtr<0>() );
auto ar = maa.template getRangePtr<0>(); auto ar = maa.template getRangePtr<0>();
auto i1 = MAT::getIndex( ar ); auto i1 = MAT::getIndex( ar );
@ -188,10 +188,10 @@ namespace
TEST_F(OpTest_MDim, ExecFOp) TEST_F(OpTest_MDim, ExecFOp)
{ {
MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr); Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
MultiArray<double,MRange> ma1(mr1ptr, v3); Array<double,MRange> ma1(mr1ptr, v3);
MultiArray<double,SRange> ma2(sr4ptr, v2); Array<double,SRange> ma2(sr4ptr, v2);
MultiArray<double,SRange> ma3(sr4ptr, v4); Array<double,SRange> ma3(sr4ptr, v4);
auto i1 = MAT::getIndex( mr1ptr ); auto i1 = MAT::getIndex( mr1ptr );
auto i2 = MAT::getIndex( sr4ptr ); auto i2 = MAT::getIndex( sr4ptr );
@ -216,13 +216,13 @@ namespace
TEST_F(OpTest_MDim, ExecDOp) TEST_F(OpTest_MDim, ExecDOp)
{ {
//typedef MultiArray<double,AnonymousRange> AMA; //typedef Array<double,AnonymousRange> AMA;
typedef MultiArray<double,DynamicRange> DMA; typedef Array<double,DynamicRange> DMA;
MultiArray<double,MRange,SRange> ma1(mr1ptr,sr4ptr,v5); Array<double,MRange,SRange> ma1(mr1ptr,sr4ptr,v5);
MultiArray<double,SRange> ma2(sr2ptr,v1); Array<double,SRange> ma2(sr2ptr,v1);
MultiArray<double,SRange,MRange> res(sr4ptr,mr1ptr); Array<double,SRange,MRange> res(sr4ptr,mr1ptr);
MultiArray<double,MRange,SRange> res2(mr1ptr,sr4ptr); Array<double,MRange,SRange> res2(mr1ptr,sr4ptr);
DMA dma1 = *std::dynamic_pointer_cast<DMA>( dynamic( ma1 ) ); DMA dma1 = *std::dynamic_pointer_cast<DMA>( dynamic( ma1 ) );
DMA dma2 = *std::dynamic_pointer_cast<DMA>( dynamic( ma2 ) ); DMA dma2 = *std::dynamic_pointer_cast<DMA>( dynamic( ma2 ) );
@ -285,13 +285,13 @@ namespace
TEST_F(OpTest_MDim, ExecOp3) TEST_F(OpTest_MDim, ExecOp3)
{ {
MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr); Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
MultiArray<double,MRange> ma1(mr1ptr, v3); Array<double,MRange> ma1(mr1ptr, v3);
MultiArray<double,SRange> ma2(sr2ptr, v1); Array<double,SRange> ma2(sr2ptr, v1);
MultiArray<double,SRange> ma3(sr4ptr, v4); Array<double,SRange> ma3(sr4ptr, v4);
MultiArray<double,SRange,SRange,SRange,SRange> ma4(sr1ptr,sr2ptr,sr3ptr,sr4ptr); Array<double,SRange,SRange,SRange,SRange> ma4(sr1ptr,sr2ptr,sr3ptr,sr4ptr);
MultiArray<double,SRange> ma5(sr1ptr, v3); Array<double,SRange> ma5(sr1ptr, v3);
MultiArray<double,SRange> ma6(sr3ptr, v2); Array<double,SRange> ma6(sr3ptr, v2);
auto si0 = MAT::getIndex( sr1ptr ); // 'x' auto si0 = MAT::getIndex( sr1ptr ); // 'x'
auto si1 = MAT::getIndex( sr2ptr ); // '1' auto si1 = MAT::getIndex( sr2ptr ); // '1'
@ -324,9 +324,9 @@ namespace
(*si3) = 0; (*si3) = 0;
Slice<double,SRange,SRange> sl(sr4ptr,sr3ptr); Slice<double,SRange,SRange> sl(sr4ptr,sr3ptr);
sl.define(si3,si2) = ma4(si0,si1,si2,si3); sl.define(si3,si2) = ma4(si0,si1,si2,si3);
MultiArrayBase<double,SRange,SRange>& slb = sl; ArrayBase<double,SRange,SRange>& slb = sl;
MultiArray<double,SRange,SRange> ma8(sr3ptr,sr4ptr); Array<double,SRange,SRange> ma8(sr3ptr,sr4ptr);
//ma8(si2,si3) = ma4(si0,si1,si2,si3); //ma8(si2,si3) = ma4(si0,si1,si2,si3);
ma8(si2,si3) = slb(si3,si2); ma8(si2,si3) = slb(si3,si2);