diff --git a/src/include/allocator.h b/src/include/allocator.h
index f894381..56ca670 100644
--- a/src/include/allocator.h
+++ b/src/include/allocator.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_allocator__
-#define __ma_allocator__
+#ifndef __cxz_allocator__
+#define __cxz_allocator__
 
 #include <cstdlib>
 #include <new>
diff --git a/src/include/arith.h b/src/include/arith.h
index 10a865f..74b1230 100644
--- a/src/include/arith.h
+++ b/src/include/arith.h
@@ -1,6 +1,6 @@
 
-#ifndef __arith_h__
-#define __arith_h__
+#ifndef __cxz_arith_h__
+#define __cxz_arith_h__
 
 #include <functional>
 
diff --git a/src/include/base_def.h b/src/include/base_def.h
index 9628956..d5d87da 100644
--- a/src/include/base_def.h
+++ b/src/include/base_def.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __base_def_h__
-#define __base_def_h__
+#ifndef __cxz_base_def_h__
+#define __cxz_base_def_h__
 
 #include <cassert>
 
diff --git a/src/include/basic_types.h b/src/include/basic_types.h
index 0e0a9c7..0c806be 100644
--- a/src/include/basic_types.h
+++ b/src/include/basic_types.h
@@ -1,5 +1,5 @@
-#ifndef __basic_types_h__
-#define __basic_types_h__
+#ifndef __cxz_basic_types_h__
+#define __cxz_basic_types_h__
 
 #include <string>
 
diff --git a/src/include/cnorxz.h b/src/include/cnorxz.h
index 212af70..6a655a5 100644
--- a/src/include/cnorxz.h
+++ b/src/include/cnorxz.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __cnorxz_h__
-#define __cnorxz_h__
+#ifndef __cxz_cnorxz_h__
+#define __cxz_cnorxz_h__
 
 #include <cstdlib>
 #include "container_index.h"
diff --git a/src/include/container_index.h b/src/include/container_index.h
index c457e44..c47d1d6 100644
--- a/src/include/container_index.h
+++ b/src/include/container_index.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __container_index_h__
-#define __container_index_h__
+#ifndef __cxz_container_index_h__
+#define __cxz_container_index_h__
 
 #include <cstdlib>
 #include <tuple>
diff --git a/src/include/conversions.h b/src/include/conversions.h
index 76ffb87..2b1dc78 100644
--- a/src/include/conversions.h
+++ b/src/include/conversions.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_conversions_h__
-#define __ma_conversions_h__
+#ifndef __cxz_conversions_h__
+#define __cxz_conversions_h__
 
 #include "cxz_array.h"
 #include "slice.h"
@@ -94,7 +94,7 @@ namespace CNORXZ
     }
 
     template <typename C, typename T, class... Ranges>
-    auto tcast(MultiArray<T,Ranges...>& ma)
+    auto tcast(Array<T,Ranges...>& ma)
 	-> decltype(rangeTpToSlice
 	    ( rtcast<C,T>( ma.range()->space() ),
 	      reinterpret_cast<C*>( ma.data() ) ))
@@ -107,7 +107,7 @@ namespace CNORXZ
     }
     
     template <typename C, typename T, class... Ranges>
-    auto tcast(const MultiArray<T,Ranges...>& ma)
+    auto tcast(const Array<T,Ranges...>& ma)
 	-> decltype(rangeTpToSlice
 	    ( rtcast<C,T>( ma.range()->space() ),
 	      reinterpret_cast<const C*>( ma.data() ) ))
diff --git a/src/include/cxz_array.cc.h b/src/include/cxz_array.cc.h
index 3d90a10..797a991 100644
--- a/src/include/cxz_array.cc.h
+++ b/src/include/cxz_array.cc.h
@@ -12,21 +12,21 @@ namespace CNORXZ
     }
     
     /*******************
-     *  MultiArray     *	     
+     *  Array     *	     
      *******************/
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const typename CRange::Space& space) :
-	MutableMultiArrayBase<T,SRanges...>(space),
+    Array<T,SRanges...>::Array(const typename CRange::Space& space) :
+	MutableArrayBase<T,SRanges...>(space),
 	mCont(MAB::mRange->size())
     {
 	MAB::mInit = true;
     }
 
     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) :
-	MutableMultiArrayBase<T,SRanges...>(space),
+	MutableArrayBase<T,SRanges...>(space),
 	mCont(vec)
     {
 	MAB::mInit = true;
@@ -37,24 +37,24 @@ namespace CNORXZ
 
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges) :
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(MAB::mRange->size())
     {
 	MAB::mInit = true;
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, const T& val) : 
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, const T& val) : 
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(MAB::mRange->size(), val)
     {
 	MAB::mInit = true;
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec) :
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(vec)
     {
 	MAB::mInit = true;
@@ -64,8 +64,8 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec) :
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mCont(std::forward<vector<T>>(vec))
     {
 	MAB::mInit = true;
@@ -76,8 +76,8 @@ namespace CNORXZ
 
     template <typename T, class... SRanges>
     template <class... Ranges>
-    MultiArray<T,SRanges...>::MultiArray(const std::shared_ptr<SRanges>&... ranges, MultiArray<T,Ranges...>&& in) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+    Array<T,SRanges...>::Array(const std::shared_ptr<SRanges>&... ranges, Array<T,Ranges...>&& in) :
+	MutableArrayBase<T,SRanges...>(ranges...),
         mCont( std::move( in.mCont ) )
     {
         // maybe some checks here in the future...
@@ -87,8 +87,8 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    MultiArray<T,SRanges...>::MultiArray(MultiArray<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes) :
-	MutableMultiArrayBase<T,SRanges...>
+    Array<T,SRanges...>::Array(Array<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes) :
+	MutableArrayBase<T,SRanges...>
 	( ama.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ),
 	mCont( std::move( ama.mCont ) )
     {
@@ -97,85 +97,85 @@ namespace CNORXZ
     }
 
     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() ];
     }
 
     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() ];
     }
 
     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() ];
     }
 
     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() ];
     }
 	
     template <typename T, class... SRanges>
-    bool MultiArray<T,SRanges...>::isConst() const
+    bool Array<T,SRanges...>::isConst() const
     {
 	return false;
     }
     
     template <typename T, class... SRanges>
-    bool MultiArray<T,SRanges...>::isSlice() const
+    bool Array<T,SRanges...>::isSlice() const
     {
 	return false;
     }
 
     template <typename T, class... SRanges>
     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;
-	return MultiArray<T,SRanges2...>( nrs... , mCont );
+	return Array<T,SRanges2...>( nrs... , mCont );
     }
 
     template <typename T, class... SRanges>
     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;
-	return MultiArray<T,SRanges2...>( nrs , mCont );
+	return Array<T,SRanges2...>( nrs , mCont );
     }
 
     template <typename T, class... SRanges>
     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() );
     }
 
     template <typename T, class... SRanges>
     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() );
     }
     
     template <typename T, class... SRanges>
-    const T* MultiArray<T,SRanges...>::data() const
+    const T* Array<T,SRanges...>::data() const
     {
 	return mCont.data();
     }
 
     template <typename T, class... SRanges>
-    T* MultiArray<T,SRanges...>::data()
+    T* Array<T,SRanges...>::data()
     {
 	return mCont.data();
     }
 
     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());
 	if(slice){
@@ -184,14 +184,14 @@ namespace CNORXZ
 		  data() );
 	}
 	else {
-	    return std::make_shared<MultiArray<T,AnonymousRange> >
+	    return std::make_shared<Array<T,AnonymousRange> >
 		( std::dynamic_pointer_cast<AnonymousRange>( arf.create() ),
 		  mCont );
 	}
     }
 
     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){
 	    x = in;
@@ -200,7 +200,7 @@ namespace CNORXZ
     }
     
     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 !!
 	    (*this) = in;
@@ -217,7 +217,7 @@ namespace CNORXZ
     }
 
     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 !!
 	    (*this) = in;
@@ -234,7 +234,7 @@ namespace CNORXZ
     }
     
     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){
 	    x *= in;
@@ -243,7 +243,7 @@ namespace CNORXZ
     }
 
     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){
 	    x /= in;
@@ -252,7 +252,7 @@ namespace CNORXZ
     }
     
     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" );
 	// TODO: check that SIZE is statically = 1 !!!
@@ -260,7 +260,7 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    auto MultiArray<T,SRanges...>::cat() const
+    auto Array<T,SRanges...>::cat() const
 	-> decltype(ArrayCatter<T>::cat(*this))
     {
 	return ArrayCatter<T>::cat(*this);
diff --git a/src/include/cxz_array.h b/src/include/cxz_array.h
index 97e98ad..7b5471f 100644
--- a/src/include/cxz_array.h
+++ b/src/include/cxz_array.h
@@ -18,49 +18,49 @@ namespace CNORXZ
     struct ArrayCatter
     {
 	template <class... Ranges>
-	static auto cat(const MultiArray<T,Ranges...>& ma)
-	    -> MultiArray<T,Ranges...>
+	static auto cat(const Array<T,Ranges...>& ma)
+	    -> Array<T,Ranges...>
 	{
 	    return ma;
 	}
     };
     
     template <typename T, class... SRanges>
-    class MultiArray : public MutableMultiArrayBase<T,SRanges...>
+    class Array : public MutableArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	
-        using MultiArrayBase<T,SRanges...>::operator[];
-	using MutableMultiArrayBase<T,SRanges...>::operator[];
+        using ArrayBase<T,SRanges...>::operator[];
+	using MutableArrayBase<T,SRanges...>::operator[];
 
-	DEFAULT_MEMBERS(MultiArray);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, const T& val);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec);
-	MultiArray(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec);
+	DEFAULT_MEMBERS(Array);
+	Array(const std::shared_ptr<SRanges>&... ranges);
+	Array(const std::shared_ptr<SRanges>&... ranges, const T& val);
+	Array(const std::shared_ptr<SRanges>&... ranges, const vector<T>& vec);
+	Array(const std::shared_ptr<SRanges>&... ranges, vector<T>&& vec);
 
         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);
-	MultiArray(const typename CRange::Space& space, const vector<T>& vec);
-	MultiArray(MultiArray<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes);
+        Array(const typename CRange::Space& space);
+	Array(const typename CRange::Space& space, const vector<T>& vec);
+	Array(Array<T,AnonymousRange>&& ama, SIZET<SRanges>... sizes);
 	
 	// Only if ALL ranges have default extensions:
-	//MultiArray(const vector<T>& vec);
-	//MultiArray(vector<T>&& vec);
+	//Array(const vector<T>& vec);
+	//Array(vector<T>&& vec);
 	
 	// 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>
-	//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 const T& operator[](const IndexType& i) const final;
@@ -71,11 +71,11 @@ namespace CNORXZ
 	virtual bool isSlice() const override;
 
 	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
 
 	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>
         Slice<T,SRanges2...> slformat(const std::shared_ptr<SRanges2>&... nrs);
@@ -89,23 +89,23 @@ namespace CNORXZ
 	virtual const vector<T>& vdata() const { return 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<MultiArrayBase<T,AnonymousRange> > anonymousMove() override;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
+	//virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymousMove() override;
 	
 	auto cat() const
 	    -> decltype(ArrayCatter<T>::cat(*this));
 	
 	operator T() const;	
 
-	MultiArray& operator=(const T& in);
+	Array& operator=(const T& in);
 	
-	MultiArray& operator+=(const MultiArray& in);
-	MultiArray& operator-=(const MultiArray& in);
-	MultiArray& operator*=(const T& in);
-	MultiArray& operator/=(const T& in);
+	Array& operator+=(const Array& in);
+	Array& operator-=(const Array& in);
+	Array& operator*=(const T& in);
+	Array& operator/=(const T& in);
 	
 	template <typename U, class... SRanges2>
-	friend class MultiArray;
+	friend class Array;
 	
     private:
 	
@@ -113,17 +113,17 @@ namespace CNORXZ
     };
 
     template <typename T>
-    using Scalar = MultiArray<T,NullRange>;
+    using Scalar = Array<T,NullRange>;
 
     template <typename T>
     Scalar<T> scalar(const T& in);
 
     template <typename T, class... ERanges>
-    struct ArrayCatter<MultiArray<T,ERanges...> >
+    struct ArrayCatter<Array<T,ERanges...> >
     {
 	template <class... Ranges>
-	static auto cat(const MultiArray<MultiArray<T,ERanges...>,Ranges...>& ma)
-	    -> MultiArray<T,Ranges...,ERanges...>
+	static auto cat(const Array<Array<T,ERanges...>,Ranges...>& ma)
+	    -> Array<T,Ranges...,ERanges...>
 	{
 	    auto sma = *ma.begin();
 	    const size_t smas = sma.size();
@@ -136,7 +136,7 @@ namespace CNORXZ
 		assert(x.size() == smas);
 		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));
 	}
     };
 
diff --git a/src/include/cxz_array_base.cc.h b/src/include/cxz_array_base.cc.h
index f24c198..2f5552b 100644
--- a/src/include/cxz_array_base.cc.h
+++ b/src/include/cxz_array_base.cc.h
@@ -5,11 +5,11 @@ namespace CNORXZ
 {
         
     /**********************
-     *  MultiArrayBase    *	     
+     *  ArrayBase    *	     
      **********************/
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>::MultiArrayBase(const MultiArrayBase& in) :
+    ArrayBase<T,SRanges...>::ArrayBase(const ArrayBase& in) :
 	mInit(in.mInit),
 	mRange(in.mRange)
     {
@@ -20,7 +20,7 @@ namespace CNORXZ
 	
 
     template <typename T, class... SRanges>
-    MultiArrayBase<T,SRanges...>::MultiArrayBase(MultiArrayBase&& in) :
+    ArrayBase<T,SRanges...>::ArrayBase(ArrayBase&& in) :
 	mInit(in.mInit),
 	mRange(in.mRange)
     {
@@ -30,7 +30,7 @@ namespace CNORXZ
     }
 
     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;
 	mRange = in.mRange;
@@ -41,7 +41,7 @@ namespace CNORXZ
     }
 
     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;
 	mRange = in.mRange;
@@ -52,7 +52,7 @@ namespace CNORXZ
     }
     
     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...);
 	mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
@@ -60,7 +60,7 @@ namespace CNORXZ
     }
 
     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);
 	mRange = std::dynamic_pointer_cast<ContainerRange<SRanges...> >( crf.create() );
@@ -69,7 +69,7 @@ namespace CNORXZ
 
     template <typename T, class... SRanges>
     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);
 	ii = i;
@@ -77,7 +77,7 @@ namespace CNORXZ
     }
 
     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);
 	ii(is);
@@ -85,25 +85,25 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    size_t MultiArrayBase<T,SRanges...>::size() const
+    size_t ArrayBase<T,SRanges...>::size() const
     {
 	return mRange->size();
     }
 
     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();
     }
     
     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();
     }
 
     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);
 	i = 0;
@@ -111,7 +111,7 @@ namespace CNORXZ
     }
     
     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);
 	i = i.max();
@@ -119,28 +119,28 @@ namespace CNORXZ
     }
 
     template <typename T, class... SRanges>
-    const std::shared_ptr<typename MultiArrayBase<T,SRanges...>::CRange>&
-    MultiArrayBase<T,SRanges...>::range() const
+    const std::shared_ptr<typename ArrayBase<T,SRanges...>::CRange>&
+    ArrayBase<T,SRanges...>::range() const
     {
 	return mRange;
     }
 
     template <typename T, class... SRanges>
-    bool MultiArrayBase<T,SRanges...>::isConst() const
+    bool ArrayBase<T,SRanges...>::isConst() const
     {
 	return true;
     }
     
     template <typename T, class... 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...);
     }
 
     template <typename T, class... 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);
     }
@@ -148,7 +148,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     template <class... 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),
 		      "number of mapped ranges must be equal to number of original ranges");
@@ -156,14 +156,14 @@ namespace CNORXZ
     }
     
     template <typename T, class... SRanges>
-    bool MultiArrayBase<T,SRanges...>::isInit() const
+    bool ArrayBase<T,SRanges...>::isInit() const
     {
 	return mInit;
     }
     
     template <typename T, class... SRanges>
     template <size_t N>
-    auto MultiArrayBase<T,SRanges...>::getRangePtr() const
+    auto ArrayBase<T,SRanges...>::getRangePtr() const
 	-> decltype(mRange->template getPtr<N>())
     {
 	return mRange->template getPtr<N>();
@@ -171,20 +171,20 @@ namespace CNORXZ
 
     
     /******************************
-     *  MutableMultiArrayBase     *	     
+     *  MutableArrayBase     *	     
      ******************************/
 
     template <typename T, class... SRanges>
-    MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges) :
-	MultiArrayBase<T,SRanges...>(ranges...) {}
+    MutableArrayBase<T,SRanges...>::MutableArrayBase(const std::shared_ptr<SRanges>&... ranges) :
+	ArrayBase<T,SRanges...>(ranges...) {}
 
     template <typename T, class... SRanges>
-    MutableMultiArrayBase<T,SRanges...>::MutableMultiArrayBase(const typename CRange::Space& space) :
-	MultiArrayBase<T,SRanges...>(space) {}
+    MutableArrayBase<T,SRanges...>::MutableArrayBase(const typename CRange::Space& space) :
+	ArrayBase<T,SRanges...>(space) {}
 
     template <typename T, class... SRanges>
     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);
 	ii = i;
@@ -192,7 +192,7 @@ namespace CNORXZ
     }
 
     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());
 	ii(is);
@@ -200,7 +200,7 @@ namespace CNORXZ
     }
 
     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);
 	i = 0;
@@ -208,7 +208,7 @@ namespace CNORXZ
     }
     
     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);
 	i = i.max();
@@ -217,35 +217,35 @@ namespace CNORXZ
 
     
     template <typename T, class... SRanges>
-    bool MutableMultiArrayBase<T,SRanges...>::isConst() const
+    bool MutableArrayBase<T,SRanges...>::isConst() const
     {
 	return false;
     }
 
     template <typename T, class... 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...);
     }
 
     template <typename T, class... 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);
     }
     
     template <typename T, class... 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...);
     }
 
     template <typename T, class... 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);
     }
@@ -253,7 +253,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     template <class... 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),
 		      "number of mapped ranges must be equal to number of original ranges");
@@ -263,7 +263,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     template <class... 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),
 		      "number of mapped ranges must be equal to number of original ranges");
diff --git a/src/include/cxz_array_base.h b/src/include/cxz_array_base.h
index 791215e..4e91609 100644
--- a/src/include/cxz_array_base.h
+++ b/src/include/cxz_array_base.h
@@ -51,7 +51,7 @@ namespace CNORXZ
 
     // Explicitely specify subranges in template argument !!!
     template <typename T, class... SRanges>
-    class MultiArrayBase
+    class ArrayBase
     {
     public:
 
@@ -67,17 +67,17 @@ namespace CNORXZ
 
     public:
 
-	//DEFAULT_MEMBERS(MultiArrayBase);
-	MultiArrayBase(const std::shared_ptr<SRanges>&... ranges);
-	MultiArrayBase(const typename CRange::Space& space);
+	//DEFAULT_MEMBERS(ArrayBase);
+	ArrayBase(const std::shared_ptr<SRanges>&... ranges);
+	ArrayBase(const typename CRange::Space& space);
 
-	MultiArrayBase() = default;
-	MultiArrayBase(const MultiArrayBase& in);
-	MultiArrayBase(MultiArrayBase&& in);
-	MultiArrayBase& operator=(const MultiArrayBase& in);
-	MultiArrayBase& operator=(MultiArrayBase&& in);
+	ArrayBase() = default;
+	ArrayBase(const ArrayBase& in);
+	ArrayBase(ArrayBase&& in);
+	ArrayBase& operator=(const ArrayBase& in);
+	ArrayBase& operator=(ArrayBase&& in);
 	
-	virtual ~MultiArrayBase() = default;
+	virtual ~ArrayBase() = default;
 
 	template <typename X>
 	const T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
@@ -100,7 +100,7 @@ namespace CNORXZ
 
 	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...>
 	op(const std::shared_ptr<CIndexType>& ind) const;
@@ -121,26 +121,26 @@ namespace CNORXZ
     };
 
     template <typename T, class... SRanges>
-    class MutableMultiArrayBase : public MultiArrayBase<T,SRanges...>
+    class MutableArrayBase : public ArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ContainerIndex<T,typename SRanges::IndexType...> IndexType;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> CIndexType;
 	
-	using MultiArrayBase<T,SRanges...>::operator[];
-	using MultiArrayBase<T,SRanges...>::at;
-	using MultiArrayBase<T,SRanges...>::data;
-	using MultiArrayBase<T,SRanges...>::begin;
-	using MultiArrayBase<T,SRanges...>::end;
-	using MultiArrayBase<T,SRanges...>::cbegin;
-	using MultiArrayBase<T,SRanges...>::cend;
+	using ArrayBase<T,SRanges...>::operator[];
+	using ArrayBase<T,SRanges...>::at;
+	using ArrayBase<T,SRanges...>::data;
+	using ArrayBase<T,SRanges...>::begin;
+	using ArrayBase<T,SRanges...>::end;
+	using ArrayBase<T,SRanges...>::cbegin;
+	using ArrayBase<T,SRanges...>::cend;
 	
-	DEFAULT_MEMBERS(MutableMultiArrayBase);
-	MutableMultiArrayBase(const std::shared_ptr<SRanges>&... ranges);
-	MutableMultiArrayBase(const typename CRange::Space& space);
+	DEFAULT_MEMBERS(MutableArrayBase);
+	MutableArrayBase(const std::shared_ptr<SRanges>&... ranges);
+	MutableArrayBase(const typename CRange::Space& space);
 
 	template <typename X>
 	T& operator[](const ConstContainerIndex<X,typename SRanges::IndexType...>& i);
diff --git a/src/include/ma_assert.h b/src/include/cxz_assert.h
similarity index 100%
rename from src/include/ma_assert.h
rename to src/include/cxz_assert.h
diff --git a/src/include/cxz_operation.cc.h b/src/include/cxz_operation.cc.h
index 3d12cae..7d50b1b 100644
--- a/src/include/cxz_operation.cc.h
+++ b/src/include/cxz_operation.cc.h
@@ -68,7 +68,7 @@ namespace CNORXZ
     template <class... Indices>
     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));
 	(*ma)(inds...) = THIS();
 	return ConstOperationRoot<T,typename Indices::RangeType...>(ma, inds...);
@@ -78,7 +78,7 @@ namespace CNORXZ
     template <class... Indices>
     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();
 	return out;
     }
@@ -87,7 +87,7 @@ namespace CNORXZ
     template <class... Indices>
     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));
         out(inds...) += THIS();
 	return out;
@@ -97,7 +97,7 @@ namespace CNORXZ
     template <class... Indices>
     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();
 	return out;
     }
@@ -106,7 +106,7 @@ namespace CNORXZ
     template <class... Indices>
     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));
         out(inds...).par() += THIS();
 	return out;
@@ -343,7 +343,7 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     ConstOperationRoot<T,Ranges...>::
-    ConstOperationRoot(const MultiArrayBase<T,Ranges...>& ma,
+    ConstOperationRoot(const ArrayBase<T,Ranges...>& ma,
 		       const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
@@ -355,7 +355,7 @@ namespace CNORXZ
 
     template <typename T, class... 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) :
 	mDataPtr(maptr->data()),
         mOrigDataPtr(maptr->data()),
@@ -517,7 +517,7 @@ namespace CNORXZ
     
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
-    OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+    OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
@@ -531,7 +531,7 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     OperationRoot<T,Ranges...>::
-    OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+    OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		  const std::tuple<std::shared_ptr<typename Ranges::IndexType>...>& indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
@@ -728,7 +728,7 @@ namespace CNORXZ
     
     template <typename T, class... Ranges>
     ParallelOperationRoot<T,Ranges...>::
-    ParallelOperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+    ParallelOperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		  const std::shared_ptr<typename Ranges::IndexType>&... indices) :
 	mDataPtr(ma.data()),
         mOrigDataPtr(ma.data()),
diff --git a/src/include/cxz_operation.h b/src/include/cxz_operation.h
index 6299e35..474f529 100644
--- a/src/include/cxz_operation.h
+++ b/src/include/cxz_operation.h
@@ -477,10 +477,10 @@ namespace CNORXZ
         static constexpr bool CONT = 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);
 
-	ConstOperationRoot(std::shared_ptr<MultiArrayBase<T,Ranges...> > maptr,
+	ConstOperationRoot(std::shared_ptr<ArrayBase<T,Ranges...> > maptr,
 			   const std::shared_ptr<typename Ranges::IndexType>&... indices);
 
 	ConstOperationRoot(const T* data, const IndexType& ind);
@@ -506,7 +506,7 @@ namespace CNORXZ
 	const T* mDataPtr;
         const T* mOrigDataPtr;
 	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>
@@ -609,10 +609,10 @@ namespace CNORXZ
 	IndexType mIndex;
 
     public:
-	OperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+	OperationRoot(MutableArrayBase<T,Ranges...>& ma,
 		      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);
 
 	OperationRoot(T* data, const IndexType& ind);
@@ -695,7 +695,7 @@ namespace CNORXZ
 	IndexType mIndex;
 
     public:
-	ParallelOperationRoot(MutableMultiArrayBase<T,Ranges...>& ma,
+	ParallelOperationRoot(MutableArrayBase<T,Ranges...>& ma,
                               const std::shared_ptr<typename Ranges::IndexType>&... indices);
 
 	ParallelOperationRoot(T* data, const IndexType& ind);
diff --git a/src/include/dynamic_operation.cc.h b/src/include/dynamic_operation.cc.h
index c0f02fe..43bbb45 100644
--- a/src/include/dynamic_operation.cc.h
+++ b/src/include/dynamic_operation.cc.h
@@ -45,7 +45,7 @@ namespace CNORXZ
     DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(const DynamicOuterOp& in) :
 	mThreadId(omp_get_thread_num()), mOp(in.mOp),
 	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),
 	mL((mThreadId != in.mThreadId) ?
 	   mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
@@ -60,7 +60,7 @@ namespace CNORXZ
     DynamicOuterOp<T,Operation,Ranges...>::DynamicOuterOp(DynamicOuterOp&& in) :
 	mThreadId(omp_get_thread_num()), mOp(in.mOp),
 	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),
 	mL((mThreadId != in.mThreadId) ?
 	   mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
@@ -79,7 +79,7 @@ namespace CNORXZ
 	mOp = in.mOp;
 	mIndices = in.mIndices;
 	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);
 	    mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
 			 std::make_tuple(mMa),
@@ -103,7 +103,7 @@ namespace CNORXZ
 	mOp = in.mOp;
 	mIndices = in.mIndices;
 	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);
 	    mL = mkILoop(std::make_tuple(*mProto.mOp,mOp), mIndices,
 			 std::make_tuple(mMa),
@@ -124,7 +124,7 @@ namespace CNORXZ
                                                           const std::shared_ptr<typename Ranges::IndexType>&... inds)
         : mThreadId(omp_get_thread_num()), 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...)),
           mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(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()),
 	  //mDyn(dyn),
 	  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...)),
           mL(std::make_tuple(*mProto.mOp,mOp), std::make_tuple(inds...),
              std::make_tuple(mMa), std::make_tuple(mProto.mOp->assign( mOp, mkMIndex(inds...) )),
diff --git a/src/include/dynamic_operation.h b/src/include/dynamic_operation.h
index 08fed92..a2973fe 100644
--- a/src/include/dynamic_operation.h
+++ b/src/include/dynamic_operation.h
@@ -1,6 +1,6 @@
 
-#ifndef __dynamic_operation_h__
-#define __dynamic_operation_h__
+#ifndef __cxz_dynamic_operation_h__
+#define __cxz_dynamic_operation_h__
 
 #include "base_def.h"
 #include "cxz_operation.h"
@@ -77,13 +77,13 @@ namespace CNORXZ
 	Operation mOp;
         //OperationRoot<T,Ranges...> mProto;
 	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;
 
 	
 	typedef ILoop<std::tuple<OperationRoot<T,Ranges...>,Operation>,
 		      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;
 	
 	
diff --git a/src/include/functional_array.cc.h b/src/include/functional_array.cc.h
index 02fb54e..01520cd 100644
--- a/src/include/functional_array.cc.h
+++ b/src/include/functional_array.cc.h
@@ -6,30 +6,30 @@ namespace CNORXZ
 
 
     /****************************
-     *   FunctionalMultiArray   *	     
+     *   FunctionalArray   *	     
      ****************************/
 
     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) :
-	MultiArrayBase<T,SRanges...>(ranges...), mFunc(func) {}
+	ArrayBase<T,SRanges...>(ranges...), mFunc(func) {}
 
     template <typename T, class Function, class... SRanges>
-    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges) :
-	MultiArrayBase<T,SRanges...>(ranges...) {}
+    FunctionalArray<T,Function,SRanges...>::FunctionalArray(const std::shared_ptr<SRanges>&... ranges) :
+	ArrayBase<T,SRanges...>(ranges...) {}
 
     template <typename T, class Function, class... SRanges>
-    FunctionalMultiArray<T,Function,SRanges...>::FunctionalMultiArray(const typename CRange::Space& space) :
-	MultiArrayBase<T,SRanges...>(space) {}
+    FunctionalArray<T,Function,SRanges...>::FunctionalArray(const typename CRange::Space& space) :
+	ArrayBase<T,SRanges...>(space) {}
 
     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) :
-	MultiArrayBase<T,SRanges...>(space), mFunc(func) {}
+	ArrayBase<T,SRanges...>(space), mFunc(func) {}
 
     
     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){
 	    mVal = Function::apply(i.meta());
@@ -41,7 +41,7 @@ namespace CNORXZ
     }
 
     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){
 	    mVal = Function::apply(meta);
@@ -53,32 +53,32 @@ namespace CNORXZ
     }
 
     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;
     }
     
     template <typename T, class Function, class... SRanges>
-    bool FunctionalMultiArray<T,Function,SRanges...>::isConst() const
+    bool FunctionalArray<T,Function,SRanges...>::isConst() const
     {
 	return true;
     }
 
     template <typename T, class Function, class... SRanges>
-    bool FunctionalMultiArray<T,Function,SRanges...>::isSlice() const
+    bool FunctionalArray<T,Function,SRanges...>::isSlice() const
     {
 	return false;
     }
 
     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
 	return nullptr;
     }
 	
     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
     {
 	if(not mMaPtr){
@@ -89,7 +89,7 @@ namespace CNORXZ
     }
 
     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
 	-> Operation<T,Function,MetaOperationRoot<SRanges>...>
     {
diff --git a/src/include/functional_array.h b/src/include/functional_array.h
index 10112dc..b8df149 100644
--- a/src/include/functional_array.h
+++ b/src/include/functional_array.h
@@ -1,6 +1,6 @@
 
-#ifndef __functional_array__
-#define __functional_array__
+#ifndef __cxz_functional_array__
+#define __cxz_functional_array__
 
 #include "cxz_array_base.h"
 #include "slice.h"
@@ -9,14 +9,14 @@ namespace CNORXZ
 {
     
     template <typename T, class Function, class... SRanges>
-    class FunctionalMultiArray : public MultiArrayBase<T,SRanges...>
+    class FunctionalArray : public ArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IndexType;
-	typedef MultiArray<T,SRanges...> MAType;
+	typedef Array<T,SRanges...> MAType;
 	typedef T value_type;
 	
     private:
@@ -27,11 +27,11 @@ namespace CNORXZ
 
     public:
 	
-	DEFAULT_MEMBERS(FunctionalMultiArray);
-	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges, const std::shared_ptr<Function>& func);
-	FunctionalMultiArray(const std::shared_ptr<SRanges>&... ranges);
-	FunctionalMultiArray(const typename CRange::Space& space);
-	FunctionalMultiArray(const typename CRange::Space& space, const std::shared_ptr<Function>& func);
+	DEFAULT_MEMBERS(FunctionalArray);
+	FunctionalArray(const std::shared_ptr<SRanges>&... ranges, const std::shared_ptr<Function>& func);
+	FunctionalArray(const std::shared_ptr<SRanges>&... ranges);
+	FunctionalArray(const typename CRange::Space& space);
+	FunctionalArray(const typename CRange::Space& space, const std::shared_ptr<Function>& func);
 	
 	virtual const T& operator[](const IndexType& i) 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 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
             -> Operation<T,Function,MetaOperationRoot<SRanges>...>;
diff --git a/src/include/helper_tools.cc.h b/src/include/helper_tools.cc.h
index 957eb96..c2dfb19 100644
--- a/src/include/helper_tools.cc.h
+++ b/src/include/helper_tools.cc.h
@@ -237,7 +237,7 @@ namespace CNORXZ
 
     template <class MArray>
     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());
 	if(slice){
@@ -246,7 +246,7 @@ namespace CNORXZ
 		  ma.data() );
 	}
 	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() ),
 		  ma.vdata() );
 	}
@@ -254,7 +254,7 @@ namespace CNORXZ
 
     template <class MArray>
     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());
 	if(slice){
@@ -263,7 +263,7 @@ namespace CNORXZ
 		  ma.data() );
 	}
 	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() ),
 		  ma.vdata() );
 	}
@@ -294,7 +294,7 @@ namespace CNORXZ
     }
     
     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>
     {
 	constexpr size_t LAST = sizeof...(RangeTypes)+1;
@@ -307,7 +307,7 @@ namespace CNORXZ
     }
 
     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>
     {
 	constexpr size_t LAST = sizeof...(RangeTypes)+1;
@@ -320,8 +320,8 @@ namespace CNORXZ
     }
 
     template <typename T, class Range1, class... RangeTypes>
-    auto dynToAnonMove(MultiArray<T,Range1,RangeTypes...,DynamicRange>&& ma)
-	-> MultiArray<T,Range1,RangeTypes...,AnonymousRange>
+    auto dynToAnonMove(Array<T,Range1,RangeTypes...,DynamicRange>&& ma)
+	-> Array<T,Range1,RangeTypes...,AnonymousRange>
     {
 	constexpr size_t LAST = sizeof...(RangeTypes)+1;
 	AnonymousRangeFactory arf(rptr<LAST>(ma)->orig());
@@ -333,7 +333,7 @@ namespace CNORXZ
     }
 
     template <typename T>
-    auto anonToDynView(const MultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,AnonymousRange>& ma)
 	-> ConstSlice<T,DynamicRange>
     {
 	DynamicRangeFactory drf(rptr<0>(ma)->orig());
@@ -342,7 +342,7 @@ namespace CNORXZ
     }
 
     template <typename T>
-    auto anonToDynView(MutableMultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(MutableArrayBase<T,AnonymousRange>& ma)
 	-> Slice<T,DynamicRange>
     {
 	DynamicRangeFactory drf(rptr<0>(ma)->orig());
@@ -351,8 +351,8 @@ namespace CNORXZ
     }
 
     template <typename T>
-    auto dynToAnonMove(MultiArray<T,DynamicRange>&& ma)
-	-> MultiArray<T,AnonymousRange>
+    auto dynToAnonMove(Array<T,DynamicRange>&& ma)
+	-> Array<T,AnonymousRange>
     {
 	AnonymousRangeFactory arf(rptr<0>(ma)->orig());
 	auto mNSpace = std::make_tuple( createExplicit( arf ) );
@@ -376,23 +376,23 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     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>
     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>
     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...);
     }
 
 }
diff --git a/src/include/helper_tools.h b/src/include/helper_tools.h
index 71f5788..dc1aab1 100644
--- a/src/include/helper_tools.h
+++ b/src/include/helper_tools.h
@@ -1,6 +1,6 @@
 
-#ifndef __helper_tools_h__
-#define __helper_tools_h__
+#ifndef __cxz_helper_tools_h__
+#define __cxz_helper_tools_h__
 
 #include "base_def.h"
 #include "slice.h"
@@ -119,35 +119,35 @@ namespace CNORXZ
     
     template <class MArray>
     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>
     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>
-    auto anonToDynView(const MultiArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,Range1,RangeTypes...,AnonymousRange>& ma)
 	-> ConstSlice<T,Range1,RangeTypes...,DynamicRange>;
 
     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>;
 
     template <typename T, class Range1, class... RangeTypes>
-    auto dynToAnonMove(MultiArray<T,Range1,RangeTypes...,DynamicRange>&& ma)
-	-> MultiArray<T,Range1,RangeTypes...,AnonymousRange>;
+    auto dynToAnonMove(Array<T,Range1,RangeTypes...,DynamicRange>&& ma)
+	-> Array<T,Range1,RangeTypes...,AnonymousRange>;
 
     template <typename T>
-    auto anonToDynView(const MultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(const ArrayBase<T,AnonymousRange>& ma)
 	-> ConstSlice<T,DynamicRange>;
 
     template <typename T>
-    auto anonToDynView(MutableMultiArrayBase<T,AnonymousRange>& ma)
+    auto anonToDynView(MutableArrayBase<T,AnonymousRange>& ma)
 	-> Slice<T,DynamicRange>;
 
     template <typename T>
-    auto dynToAnonMove(MultiArray<T,DynamicRange>&& ma)
-	-> MultiArray<T,AnonymousRange>;
+    auto dynToAnonMove(Array<T,DynamicRange>&& ma)
+	-> Array<T,AnonymousRange>;
 
     template <class Range>
     auto metaSlice(const std::shared_ptr<Range>& r)
@@ -159,15 +159,15 @@ namespace CNORXZ
 
     template <typename T, class... Ranges>
     auto mkArray(const std::shared_ptr<Ranges>&... rs)
-        -> MultiArray<T,Ranges...>;
+        -> Array<T,Ranges...>;
 
     template <typename T, class... Ranges>
     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>
     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>
     auto mkILoop(const OpTp& opTp, const IndTp& indTp, const VarTp& varTp, const LTp& lTp,
@@ -214,11 +214,11 @@ namespace CNORXZ
 
     template <class Index>
     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> >
 		    ().exec(i))
     {
-	FunctionalMultiArray<typename Index::MetaType,
+	FunctionalArray<typename Index::MetaType,
 			     identity<typename Index::MetaType>,
 			     typename Index::RangeType> fma(i->range());
 	return fma.exec(i);
diff --git a/src/include/high_level_operation.h b/src/include/high_level_operation.h
index 71706fa..b2fafa8 100644
--- a/src/include/high_level_operation.h
+++ b/src/include/high_level_operation.h
@@ -1,6 +1,6 @@
 
-#ifndef __high_level_operation_h__
-#define __high_level_operation_h__
+#ifndef __cxz_high_level_operation_h__
+#define __cxz_high_level_operation_h__
 
 #include "base_def.h"
 #include "ranges/rheader.h"
diff --git a/src/include/map_range.cc.h b/src/include/map_range.cc.h
index 8cc780e..d9c0cd5 100644
--- a/src/include/map_range.cc.h
+++ b/src/include/map_range.cc.h
@@ -415,7 +415,7 @@ namespace CNORXZ
     struct OutRangeMaker<SpaceType::ANY>
     {
         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;
             for(auto ii = mapf.begin(); ii.max() != ii.pos(); ++ii) {
@@ -434,7 +434,7 @@ namespace CNORXZ
 
             typename ORType::FType orf(outmeta);
             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>
     {
         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,
                            "out range value type for NONE must be size_t" );
@@ -464,7 +464,7 @@ namespace CNORXZ
 
             typename ORType::FType orf(max);
             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>
     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);
         auto i = mapf.begin();
         mMapPos.resize(i.max());
@@ -666,7 +666,7 @@ namespace CNORXZ
 
     template <class ORType, class Op, SpaceType XSTYPE, class... Ranges>
     auto GenMapRange<ORType,Op,XSTYPE,Ranges...>::mapMultiplicity() const
-	-> const MultiArray<size_t,ORType>&
+	-> const Array<size_t,ORType>&
     {
 	return mMapMult;
     }
diff --git a/src/include/map_range.h b/src/include/map_range.h
index 9532f2b..024a7f5 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __map_range_h__
-#define __map_range_h__
+#ifndef __cxz_map_range_h__
+#define __cxz_map_range_h__
 
 #include <cstdlib>
 #include <tuple>
@@ -29,12 +29,12 @@ namespace CNORXZ
     template <class Func, class... Indices>
     auto mkMapOp(const std::shared_ptr<Func>& func,
 		 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...),
-                                    FunctionalMultiArray<typename Func::value_type,Func,
+                                    FunctionalArray<typename Func::value_type,Func,
                                     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){
             FMA fma(is->range()...);
             return std::make_tuple(fma.exec(is...),fma);
@@ -277,7 +277,7 @@ namespace CNORXZ
         Op mMapf;
 	//Op mMapf;
 	std::shared_ptr<ORType> mOutRange;
-	MultiArray<size_t,ORType> mMapMult;
+	Array<size_t,ORType> mMapMult;
         vector<size_t> mMapPos;
         
     private:
@@ -314,7 +314,7 @@ namespace CNORXZ
 	virtual IndexType begin() 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;
 
         vector<size_t> mapPos() const;
diff --git a/src/include/map_range_factory_product_map.h b/src/include/map_range_factory_product_map.h
index cc89ed2..8406e07 100644
--- a/src/include/map_range_factory_product_map.h
+++ b/src/include/map_range_factory_product_map.h
@@ -1,6 +1,6 @@
 
-#ifndef __map_range_factory_product_map_h__
-#define __map_range_factory_product_map_h__
+#ifndef __cxz_map_range_factory_product_map_h__
+#define __cxz_map_range_factory_product_map_h__
 
 #include <memory>
 #include <vector>
diff --git a/src/include/mbase_def.h b/src/include/mbase_def.h
index 39eb5a4..16b07cd 100644
--- a/src/include/mbase_def.h
+++ b/src/include/mbase_def.h
@@ -1,6 +1,6 @@
 
-#ifndef __mbase_def_h__
-#define __mbase_def_h__
+#ifndef __cxz_mbase_def_h__
+#define __cxz_mbase_def_h__
 
 #include "ranges/rbase_def.h"
 #include "allocator.h"
@@ -23,15 +23,15 @@ namespace CNORXZ
 
     // cxz_array.h
     template <typename T, class... SRanges>
-    class MultiArrayBase;
+    class ArrayBase;
 
     // cxz_array.h
     template <typename T, class... SRanges>
-    class MutableMultiArrayBase;
+    class MutableArrayBase;
     
     // cxz_array.h
     template <typename T, class... SRanges>
-    class MultiArray;
+    class Array;
    
     // cxz_operation.h
     template <typename T, class OperationClass>
diff --git a/src/include/operation_def.h b/src/include/operation_def.h
index 287970c..7dcb685 100644
--- a/src/include/operation_def.h
+++ b/src/include/operation_def.h
@@ -1,6 +1,6 @@
 
-#ifndef __operation_def_h__
-#define __operation_def_h__
+#ifndef __cxz_operation_def_h__
+#define __cxz_operation_def_h__
 
 #include "cxz_operation.h"
 
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index 031d0c0..643a159 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/src/include/ranges/anonymous_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __anonymous_range_h__
-#define __anonymous_range_h__
+#ifndef __cxz_anonymous_range_h__
+#define __cxz_anonymous_range_h__
 
 #include <cstdlib>
 #include <map>
diff --git a/src/include/ranges/dynamic_meta.h b/src/include/ranges/dynamic_meta.h
index 51535aa..a1a4d60 100644
--- a/src/include/ranges/dynamic_meta.h
+++ b/src/include/ranges/dynamic_meta.h
@@ -1,6 +1,6 @@
 
-#ifndef __dynamic_meta_h__
-#define __dynamic_meta_h__
+#ifndef __cxz_dynamic_meta_h__
+#define __cxz_dynamic_meta_h__
 
 #include <cstdlib>
 #include <utility>
diff --git a/src/include/ranges/dynamic_range.h b/src/include/ranges/dynamic_range.h
index f0075c6..e69f487 100644
--- a/src/include/ranges/dynamic_range.h
+++ b/src/include/ranges/dynamic_range.h
@@ -1,6 +1,6 @@
 
-#ifndef __dynamic_range_h__
-#define __dynamic_range_h__
+#ifndef __cxz_dynamic_range_h__
+#define __cxz_dynamic_range_h__
 
 #include <cassert>
 #include <map>
diff --git a/src/include/ranges/index_base.h b/src/include/ranges/index_base.h
index 9c0c4b2..627a907 100644
--- a/src/include/ranges/index_base.h
+++ b/src/include/ranges/index_base.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __index_base_h__
-#define __index_base_h__
+#ifndef __cxz_index_base_h__
+#define __cxz_index_base_h__
 
 #include <cstdlib>
 #include <string>
diff --git a/src/include/ranges/index_type.h b/src/include/ranges/index_type.h
index ac5e0fd..c57938f 100644
--- a/src/include/ranges/index_type.h
+++ b/src/include/ranges/index_type.h
@@ -1,6 +1,6 @@
 
-#ifndef __index_type_h__
-#define __index_type_h__
+#ifndef __cxz_index_type_h__
+#define __cxz_index_type_h__
 
 namespace CNORXZ
 {
diff --git a/src/include/ranges/index_wrapper.h b/src/include/ranges/index_wrapper.h
index 580412e..28efcf6 100644
--- a/src/include/ranges/index_wrapper.h
+++ b/src/include/ranges/index_wrapper.h
@@ -1,6 +1,6 @@
 
-#ifndef __index_wrapper_h__
-#define __index_wrapper_h__
+#ifndef __cxz_index_wrapper_h__
+#define __cxz_index_wrapper_h__
 
 #include "ranges/rbase_def.h"
 #include "xfor/xfor.h"
diff --git a/src/include/ranges/multi_range.h b/src/include/ranges/multi_range.h
index 3ab22d6..6efda26 100644
--- a/src/include/ranges/multi_range.h
+++ b/src/include/ranges/multi_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __multi_range_h__
-#define __multi_range_h__
+#ifndef __cxz_multi_range_h__
+#define __cxz_multi_range_h__
 
 #include <cstdlib>
 #include <tuple>
diff --git a/src/include/ranges/multi_range_factory_product_map.h b/src/include/ranges/multi_range_factory_product_map.h
index 6630b1d..adba8ce 100644
--- a/src/include/ranges/multi_range_factory_product_map.h
+++ b/src/include/ranges/multi_range_factory_product_map.h
@@ -1,6 +1,6 @@
 
-#ifndef __multi_range_factory_product_map_h__
-#define __multi_range_factory_product_map_h__
+#ifndef __cxz_multi_range_factory_product_map_h__
+#define __cxz_multi_range_factory_product_map_h__
 
 #include <memory>
 #include <vector>
diff --git a/src/include/ranges/range_base.h b/src/include/ranges/range_base.h
index a701e3d..548d3da 100644
--- a/src/include/ranges/range_base.h
+++ b/src/include/ranges/range_base.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __range_base_h__
-#define __range_base_h__
+#ifndef __cxz_range_base_h__
+#define __cxz_range_base_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/range_helper.h b/src/include/ranges/range_helper.h
index 53f1462..d60f78a 100644
--- a/src/include/ranges/range_helper.h
+++ b/src/include/ranges/range_helper.h
@@ -1,6 +1,6 @@
 
-#ifndef __range_helper_h__
-#define __range_helper_h__
+#ifndef __cxz_range_helper_h__
+#define __cxz_range_helper_h__
 
 namespace CNORXZ
 {
diff --git a/src/include/ranges/range_types/classic_range.h b/src/include/ranges/range_types/classic_range.h
index 492d66a..dccd37e 100644
--- a/src/include/ranges/range_types/classic_range.h
+++ b/src/include/ranges/range_types/classic_range.h
@@ -4,11 +4,11 @@
 //#else
 
 #ifndef include_range_type
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 // assert, that this is only used within range_types/header.h
 
-#ifndef __range_type_classic_def__
-#define __range_type_classic_def__
+#ifndef __cxz_range_type_classic_def__
+#define __cxz_range_type_classic_def__
 
 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
diff --git a/src/include/ranges/range_types/header.h b/src/include/ranges/range_types/header.h
index 6fef0a9..2026d20 100644
--- a/src/include/ranges/range_types/header.h
+++ b/src/include/ranges/range_types/header.h
@@ -1,19 +1,19 @@
 
 #ifdef include_range_type
-#define __incl_this__
+#define __cxz_incl_this__
 #endif
-#ifdef __single_range_h__
+#ifdef __cxz_single_range_h__
 // singel_range is template which is specialized here
 // therefore it must be defined before...
-#define __incl_this__
+#define __cxz_incl_this__
 #endif
 
-#ifdef __incl_this__
+#ifdef __cxz_incl_this__
 
 
-#define __ranges_header__
-//#ifndef __ranges_header__
-//#define __ranges_header__
+#define __cxz_ranges_header__
+//#ifndef __cxz_ranges_header__
+//#define __cxz_ranges_header__
 
 #include "null_range.h"
 #include "spin_range.h"
diff --git a/src/include/ranges/range_types/null_range.h b/src/include/ranges/range_types/null_range.h
index b87e39e..810ce30 100644
--- a/src/include/ranges/range_types/null_range.h
+++ b/src/include/ranges/range_types/null_range.h
@@ -4,11 +4,11 @@
 include_range_type(NUL,-2)
 #else
 
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 // assert, that this is only used within range_types/header.h
 
-#ifndef __range_type_null_def__
-#define __range_type_null_def__
+#ifndef __cxz_range_type_null_def__
+#define __cxz_range_type_null_def__
 
 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
diff --git a/src/include/ranges/range_types/space_range.h b/src/include/ranges/range_types/space_range.h
index badc9d7..3c3c6a5 100644
--- a/src/include/ranges/range_types/space_range.h
+++ b/src/include/ranges/range_types/space_range.h
@@ -3,10 +3,10 @@
 include_range_type(PSPACE,3) // Periodic 1dim space
 #else
 
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 
-#ifndef __range_type_space_def__
-#define __range_type_space_def__
+#ifndef __cxz_range_type_space_def__
+#define __cxz_range_type_space_def__
 
 namespace CNORXZ
 {
@@ -128,8 +128,8 @@ namespace CNORXZ
     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
diff --git a/src/include/ranges/range_types/spin_range.h b/src/include/ranges/range_types/spin_range.h
index 256f9be..c88dcb7 100644
--- a/src/include/ranges/range_types/spin_range.h
+++ b/src/include/ranges/range_types/spin_range.h
@@ -4,11 +4,11 @@
 include_range_type(SPIN,2)
 #else
 
-#ifdef __ranges_header__
+#ifdef __cxz_ranges_header__
 // assert, that this is only used within range_types/header.h
 
-#ifndef __range_type_spin_def__
-#define __range_type_spin_def__
+#ifndef __cxz_range_type_spin_def__
+#define __cxz_range_type_spin_def__
 
 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
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index 2aa04fa..57a1943 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __ranges_base_def_h__
-#define __ranges_base_def_h__
+#ifndef __cxz_ranges_base_def_h__
+#define __cxz_ranges_base_def_h__
 
 #include <cstdlib>
 
diff --git a/src/include/ranges/reg_ind_num.h b/src/include/ranges/reg_ind_num.h
index c7b9640..6fc4bd4 100644
--- a/src/include/ranges/reg_ind_num.h
+++ b/src/include/ranges/reg_ind_num.h
@@ -1,6 +1,6 @@
 
-#ifndef __reg_ind_num_h__
-#define __reg_ind_num_h__
+#ifndef __cxz_reg_ind_num_h__
+#define __cxz_reg_ind_num_h__
 
 
 
diff --git a/src/include/ranges/rheader.h b/src/include/ranges/rheader.h
index 6c88ee0..c9ea0c4 100644
--- a/src/include/ranges/rheader.h
+++ b/src/include/ranges/rheader.h
@@ -1,6 +1,6 @@
 
-//#ifndef __rheader_h__
-//#define __rheader_h__
+//#ifndef __cxz_rheader_h__
+//#define __cxz_rheader_h__
 
 #include "dynamic_range.h"
 #include "rpheader.h"
diff --git a/src/include/ranges/rpheader.h b/src/include/ranges/rpheader.h
index 3de270f..c6ecd37 100644
--- a/src/include/ranges/rpheader.h
+++ b/src/include/ranges/rpheader.h
@@ -1,6 +1,6 @@
 
-//#ifndef __rpheader_h__
-//#define __rpheader_h__
+//#ifndef __cxz_rpheader_h__
+//#define __cxz_rpheader_h__
 
 #include "single_range.h"
 #include "multi_range.h"
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index 17d5887..c6e417f 100644
--- a/src/include/ranges/single_range.h
+++ b/src/include/ranges/single_range.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 
-#ifndef __single_range_h__
-#define __single_range_h__
+#ifndef __cxz_single_range_h__
+#define __cxz_single_range_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/subrange.h b/src/include/ranges/subrange.h
index e34bea7..c1b128c 100644
--- a/src/include/ranges/subrange.h
+++ b/src/include/ranges/subrange.h
@@ -1,6 +1,6 @@
 
-#ifndef __subrange_h__
-#define __subrange_h__
+#ifndef __cxz_subrange_h__
+#define __cxz_subrange_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/type_map.h b/src/include/ranges/type_map.h
index 3f65c7b..5e41ad1 100644
--- a/src/include/ranges/type_map.h
+++ b/src/include/ranges/type_map.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_type_map_h__
-#define __ma_type_map_h__
+#ifndef __cxz_type_map_h__
+#define __cxz_type_map_h__
 
 #include <string>
 #include <vector>
diff --git a/src/include/ranges/value_range.h b/src/include/ranges/value_range.h
index db236e1..fd9b0ec 100644
--- a/src/include/ranges/value_range.h
+++ b/src/include/ranges/value_range.h
@@ -1,6 +1,6 @@
 
-#ifndef __value_range_h__
-#define __value_range_h__
+#ifndef __cxz_value_range_h__
+#define __cxz_value_range_h__
 
 #include <cstdlib>
 #include <vector>
diff --git a/src/include/ranges/x_to_string.h b/src/include/ranges/x_to_string.h
index aa66616..547d657 100644
--- a/src/include/ranges/x_to_string.h
+++ b/src/include/ranges/x_to_string.h
@@ -1,6 +1,6 @@
 
-#ifndef __x_to_string_h__
-#define __x_to_string_h__
+#ifndef __cxz_x_to_string_h__
+#define __cxz_x_to_string_h__
 
 #include <string>
 #include <vector>
diff --git a/src/include/slice.cc.h b/src/include/slice.cc.h
index 5a118e3..84a9338 100644
--- a/src/include/slice.cc.h
+++ b/src/include/slice.cc.h
@@ -17,7 +17,7 @@ namespace CNORXZ
     template <typename T, class... SRanges>
     ConstSlice<T,SRanges...>::ConstSlice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
 					 const T* data) :
-	MultiArrayBase<T,SRanges...>(ranges),
+	ArrayBase<T,SRanges...>(ranges),
 	mData(data)
     {
 	MAB::mInit = true;
@@ -25,15 +25,15 @@ namespace CNORXZ
     
     template <typename T, class... SRanges>
     ConstSlice<T,SRanges...>::ConstSlice(const std::shared_ptr<SRanges>&... ranges, const T* data) :
-	MultiArrayBase<T,SRanges...>(ranges...),
+	ArrayBase<T,SRanges...>(ranges...),
 	mData(data)
     {
 	MAB::mInit = true;
     }
 
     template <typename T, class... SRanges>
-    ConstSlice<T,SRanges...>::ConstSlice(const MultiArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes) :
-	MultiArrayBase<T,SRanges...>
+    ConstSlice<T,SRanges...>::ConstSlice(const ArrayBase<T,AnonymousRange>& ma, SIZET<SRanges>... sizes) :
+	ArrayBase<T,SRanges...>
 	( ma.range()->template get<0>().template scast<SRanges...>(sizes...)->space() ),
 	mData( ma.data() )
     {
@@ -87,7 +87,7 @@ namespace CNORXZ
     }
     
     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(not MAB::mProtoI->sliceMode()); // only originally ordered slices!
@@ -118,13 +118,13 @@ namespace CNORXZ
     
     template <typename T, class... SRanges>
     Slice<T,SRanges...>::Slice(const std::shared_ptr<SRanges>&... ranges, T* data) :
-	MutableMultiArrayBase<T,SRanges...>(ranges...),
+	MutableArrayBase<T,SRanges...>(ranges...),
 	mData(data) {}
 
     template <typename T, class... SRanges>
     Slice<T,SRanges...>::Slice(const std::tuple<std::shared_ptr<SRanges>...>& ranges,
 			       T* data) :
-	MutableMultiArrayBase<T,SRanges...>(ranges),
+	MutableArrayBase<T,SRanges...>(ranges),
 	mData(data)
     {
 	MAB::mInit = true;
@@ -208,14 +208,14 @@ namespace CNORXZ
     }
 
     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!!!!
 	return nullptr;
     }
     /*
     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!!!!
 	return nullptr;
diff --git a/src/include/slice.h b/src/include/slice.h
index 68b4c27..dbc9a01 100644
--- a/src/include/slice.h
+++ b/src/include/slice.h
@@ -1,6 +1,6 @@
 
-#ifndef __slice_h__
-#define __slice_h__
+#ifndef __cxz_slice_h__
+#define __cxz_slice_h__
 
 #include "cxz_array_base.h"
 #include "cxz_operation.h"
@@ -8,23 +8,23 @@
 namespace CNORXZ
 {
     template <typename T, class... SRanges>
-    class ConstSlice : public MultiArrayBase<T,SRanges...>
+    class ConstSlice : public ArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
-	using MultiArrayBase<T,SRanges...>::operator();
-        using MultiArrayBase<T,SRanges...>::operator[];
+	using ArrayBase<T,SRanges...>::operator();
+        using ArrayBase<T,SRanges...>::operator[];
 	
 	DEFAULT_MEMBERS(ConstSlice);
 
 	ConstSlice(const std::tuple<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& at(const typename IType::MetaType& meta) const override;
@@ -36,7 +36,7 @@ namespace CNORXZ
 	virtual auto begin() 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)
 	    -> ConstSliceDef<T,SRanges...>;
@@ -51,18 +51,18 @@ namespace CNORXZ
 
     
     template <typename T, class... SRanges>
-    class Slice : public MutableMultiArrayBase<T,SRanges...>
+    class Slice : public MutableArrayBase<T,SRanges...>
     {
     public:
 
 	typedef ContainerRange<SRanges...> CRange;
-	typedef MultiArrayBase<T,SRanges...> MAB;
+	typedef ArrayBase<T,SRanges...> MAB;
 	typedef ConstContainerIndex<T,typename SRanges::IndexType...> IType;
 
-	using MultiArrayBase<T,SRanges...>::operator();
-	using MutableMultiArrayBase<T,SRanges...>::operator();
-        using MultiArrayBase<T,SRanges...>::operator[];
-	using MutableMultiArrayBase<T,SRanges...>::operator[];
+	using ArrayBase<T,SRanges...>::operator();
+	using MutableArrayBase<T,SRanges...>::operator();
+        using ArrayBase<T,SRanges...>::operator[];
+	using MutableArrayBase<T,SRanges...>::operator[];
 
 	DEFAULT_MEMBERS(Slice);
 
@@ -85,8 +85,8 @@ namespace CNORXZ
 	virtual auto begin() 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<MultiArrayBase<T,AnonymousRange> > anonymousMove() override;
+	virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymous(bool slice = false) const override;
+	//virtual std::shared_ptr<ArrayBase<T,AnonymousRange> > anonymousMove() override;
 
 	auto define(const std::shared_ptr<typename SRanges::IndexType>&... inds)
 	    -> SliceDef<T,SRanges...>;
diff --git a/src/include/statics/static_for.h b/src/include/statics/static_for.h
index d8758ed..63ff959 100644
--- a/src/include/statics/static_for.h
+++ b/src/include/statics/static_for.h
@@ -1,6 +1,6 @@
 
-#ifndef __static_for_h__
-#define __static_for_h__
+#ifndef __cxz_static_for_h__
+#define __cxz_static_for_h__
 
 #include <cstdlib>
 
diff --git a/src/include/statics/traits.h b/src/include/statics/traits.h
index 2a97631..9f16627 100644
--- a/src/include/statics/traits.h
+++ b/src/include/statics/traits.h
@@ -14,10 +14,10 @@ namespace CNORXZ
         static constexpr bool VALUE = true; \
     }
 
-    add_array_trait(MultiArrayBase);
-    add_array_trait(MutableMultiArrayBase);
-    add_array_trait(MultiArray);
-    add_array_trait(FunctionalMultiArray);
+    add_array_trait(ArrayBase);
+    add_array_trait(MutableArrayBase);
+    add_array_trait(Array);
+    add_array_trait(FunctionalArray);
     add_array_trait(Slice);
     add_array_trait(ConstSlice);
 
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index acebd59..60a6f74 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -1,6 +1,6 @@
 
-#ifndef __type_operations_h__
-#define __type_operations_h__
+#ifndef __cxz_type_operations_h__
+#define __cxz_type_operations_h__
 
 #include <cstdlib>
 #include <vector>
@@ -20,7 +20,7 @@ namespace CNORXZ
 	using namespace CNORXZInternal;
     }
 
-    // MultiArray
+    // Array
     
     template <typename T, class... Ranges>
     class operate
@@ -30,7 +30,7 @@ namespace CNORXZ
 
 	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...>
 	{
 	    return unpack<0,sizeof...(Ranges),0>
@@ -46,9 +46,9 @@ namespace CNORXZ
     };
 
     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)
 	    -> Operation<OperationRoot<T,Ranges...>,operate<T,Ranges...>,OperationClass>
diff --git a/src/include/xfor/exttype.h b/src/include/xfor/exttype.h
index fc72b50..1ff460a 100644
--- a/src/include/xfor/exttype.h
+++ b/src/include/xfor/exttype.h
@@ -1,6 +1,6 @@
 
-#ifndef __exttype_h__
-#define __exttype_h__
+#ifndef __cxz_exttype_h__
+#define __cxz_exttype_h__
 
 #include <array>
 
diff --git a/src/include/xfor/for_type.h b/src/include/xfor/for_type.h
index 7880ed7..6833c99 100644
--- a/src/include/xfor/for_type.h
+++ b/src/include/xfor/for_type.h
@@ -1,6 +1,6 @@
 
-#ifndef __for_type_h__
-#define __for_type_h__
+#ifndef __cxz_for_type_h__
+#define __cxz_for_type_h__
 
 namespace CNORXZInternal
 {
diff --git a/src/include/xfor/for_utils.h b/src/include/xfor/for_utils.h
index 5722d7e..453ea53 100644
--- a/src/include/xfor/for_utils.h
+++ b/src/include/xfor/for_utils.h
@@ -1,6 +1,6 @@
 
-#ifndef __for_utils_h__
-#define __for_utils_h__
+#ifndef __cxz_for_utils_h__
+#define __cxz_for_utils_h__
 
 //#include "ranges/rheader.h"
 #include <array>
diff --git a/src/include/xfor/iloop.h b/src/include/xfor/iloop.h
index c54aaad..8c74ae9 100644
--- a/src/include/xfor/iloop.h
+++ b/src/include/xfor/iloop.h
@@ -1,6 +1,6 @@
 
-#ifndef __ma_iloop_h__
-#define __ma_iloop_h__
+#ifndef __cxz_iloop_h__
+#define __cxz_iloop_h__
 
 #include <cstdlib>
 #include <memory>
diff --git a/src/include/xfor/xfor.h b/src/include/xfor/xfor.h
index 2125538..3880b6c 100644
--- a/src/include/xfor/xfor.h
+++ b/src/include/xfor/xfor.h
@@ -1,6 +1,6 @@
 
-#ifndef __xfor_h__
-#define __xfor_h__
+#ifndef __cxz_xfor_h__
+#define __cxz_xfor_h__
 
 #include <cstdlib>
 #include <memory>
diff --git a/src/lib/ranges/anonymous_range.cc b/src/lib/ranges/anonymous_range.cc
index 9f2f652..acf7266 100644
--- a/src/lib/ranges/anonymous_range.cc
+++ b/src/lib/ranges/anonymous_range.cc
@@ -1,7 +1,7 @@
 
 #include "ranges/anonymous_range.h"
 #include "ranges/ranges_header.cc.h"
-#include "ma_assert.h"
+#include "cxz_assert.h"
 
 namespace CNORXZ
 {
diff --git a/src/lib/ranges/dynamic_range.cc b/src/lib/ranges/dynamic_range.cc
index fc02940..2ec7bfe 100644
--- a/src/lib/ranges/dynamic_range.cc
+++ b/src/lib/ranges/dynamic_range.cc
@@ -1,7 +1,7 @@
 
 #include "ranges/dynamic_range.h"
 #include "ranges/ranges_header.cc.h"
-#include "ma_assert.h"
+#include "cxz_assert.h"
 
 namespace CNORXZ
 {
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index bad8c59..fa99e9a 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -10,8 +10,8 @@ add_dependencies(autest multiarray)
 target_link_libraries(autest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
 add_test(NAME autest COMMAND autest)
 
-#add_executable(mautest src/tests/ma_unit_test.cc ${MA_CC_FILES})
-add_executable(mautest ma_unit_test.cc)
+#add_executable(mautest src/tests/array_unit_test.cc ${MA_CC_FILES})
+add_executable(mautest array_unit_test.cc)
 add_dependencies(mautest multiarray)
 target_link_libraries(mautest ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} multiarray)
 add_test(NAME mautest COMMAND mautest)
diff --git a/src/tests/ma_unit_test.cc b/src/tests/array_unit_test.cc
similarity index 94%
rename from src/tests/ma_unit_test.cc
rename to src/tests/array_unit_test.cc
index bc85a74..1fa0e55 100644
--- a/src/tests/ma_unit_test.cc
+++ b/src/tests/array_unit_test.cc
@@ -98,7 +98,7 @@ namespace {
 
     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.isConst(), false);
 	EXPECT_EQ( ma.isSlice(), false);	
@@ -115,7 +115,7 @@ namespace {
     TEST_F(MATest_1Dim, ForLoop)
     {
 	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;
 	for(auto el: ma){
 
@@ -142,7 +142,7 @@ namespace {
 	swapFactory<SRF>( rfbptr, { 'a', 'c', 'e', 'g', 'i' } );
 	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();
 	EXPECT_EQ( ma[ i.at('x') ], 3.141);
 
@@ -158,7 +158,7 @@ namespace {
 
     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.range()->dim(), 2u );
 
@@ -175,7 +175,7 @@ namespace {
     
     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 i = ma2.cbegin();
@@ -188,7 +188,7 @@ namespace {
 
     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);
 
 	auto i = MAT::getIndex(sr3ptr);
diff --git a/src/tests/op2_unit_test.cc b/src/tests/op2_unit_test.cc
index 4d5be4d..0e7eb7d 100644
--- a/src/tests/op2_unit_test.cc
+++ b/src/tests/op2_unit_test.cc
@@ -119,7 +119,7 @@ namespace
 
     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 ) );
@@ -127,8 +127,8 @@ namespace
         
         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);
-	MultiArray<double,MpRange> res(mr);
-	MultiArray<double,MpRange> res2(mr);
+	Array<double,MpRange> res(mr);
+	Array<double,MpRange> res2(mr);
 	auto jj = getIndex( mr );
 	(*jj)(ii1,ii2);
 	///auto jj = mkMapI( std::make_shared<plus<size_t> >(), ii1, ii1 );
@@ -137,8 +137,8 @@ namespace
 	auto mult = mr->explMapMultiplicity();
         res2(jj) += ma1(ii1,ii2) / staticcast<double>( mult(jj) );
 
-	MultiArray<double,TRange> form = res.format(mpr1ptr->outRange());
-	MultiArray<double,TRange> form2 = res2.format(mpr1ptr->outRange());
+	Array<double,TRange> form = res.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()->mapMultiplicity().at(9), static_cast<size_t>( 3 ) );
@@ -169,7 +169,7 @@ namespace
     
     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();
 	
@@ -178,8 +178,8 @@ namespace
 
     TEST_F(MetaOp_Test, Operation)
     {
-	FunctionalMultiArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
-	MultiArray<double,SR> res( sr1ptr );
+	FunctionalArray<double,Pow<double>,SR,SR> fma(sr1ptr, sr2ptr);
+	Array<double,SR> res( sr1ptr );
 
 	auto i1 = MAT::getIndex(sr1ptr);
 	auto i2 = MAT::getIndex(sr2ptr);
@@ -203,14 +203,14 @@ namespace
 
     TEST_F(OpTest_Sub, Exec)
     {
-        MultiArray<double,SRange,SRange,SRange> ma1(sr1ptr, sr2ptr, sr3ptr, v1);
-        MultiArray<double,SRange,SRange> ma2(sr3ptr, sr2ptr, v2);
+        Array<double,SRange,SRange,SRange> ma1(sr1ptr, sr2ptr, sr3ptr, v1);
+        Array<double,SRange,SRange> ma2(sr3ptr, sr2ptr, v2);
 
         SubRangeFactory<SRange> subf(sr2ptr, vector<size_t>({0,2}));
         auto subptr = MAT::createExplicit(subf);
         
-        MultiArray<double,SRange,SRange> res(sr3ptr,sr1ptr,0.);
-	MultiArray<double,SRange,SubRange<SRange>,SRange> res2(sr3ptr,subptr,sr1ptr,0.);
+        Array<double,SRange,SRange> res(sr3ptr,sr1ptr,0.);
+	Array<double,SRange,SubRange<SRange>,SRange> res2(sr3ptr,subptr,sr1ptr,0.);
 
         auto i1 = MAT::getIndex( sr1ptr );
         auto i2 = MAT::getIndex( sr2ptr );
diff --git a/src/tests/op3_unit_test.cc b/src/tests/op3_unit_test.cc
index e211634..f69213a 100644
--- a/src/tests/op3_unit_test.cc
+++ b/src/tests/op3_unit_test.cc
@@ -31,9 +31,9 @@ namespace
 
     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);
-	MultiArray<double,SR,SR> res1( sr, sr );
-	MultiArray<double,SR,SR> res2( sr, sr );
+	Array<double,SR,SR,SR,SR,SR,SR,SR,SR> ma(sr, sr, sr, sr, sr, sr, sr, sr, data);
+	Array<double,SR,SR> res1( sr, sr );
+	Array<double,SR,SR> res2( sr, sr );
 	
 	auto alpha = 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);
 	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;
 
 	res2(delta, deltap).par() += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(alpha).c(beta).c(gamma);
diff --git a/src/tests/op4_unit_test.cc b/src/tests/op4_unit_test.cc
index 0dd6c16..de0436a 100644
--- a/src/tests/op4_unit_test.cc
+++ b/src/tests/op4_unit_test.cc
@@ -43,13 +43,13 @@ namespace
     {
     protected:
 
-	MultiArray<double,CR,DR> ma1;
-	MultiArray<double,CR,DR> ma2;
-	MultiArray<double,DR> ma3;
-	MultiArray<double,DR> ma5;
+	Array<double,CR,DR> ma1;
+	Array<double,CR,DR> ma2;
+	Array<double,DR> ma3;
+	Array<double,DR> ma5;
 
-	MultiArray<double,CR,DR> res1;
-	MultiArray<double,CR,DR> res2;
+	Array<double,CR,DR> res1;
+	Array<double,CR,DR> res2;
 
 	std::map<std::string,std::shared_ptr<IndexW>> imap;
 
diff --git a/src/tests/op_perf_test.cc b/src/tests/op_perf_test.cc
index 6e32837..6c8bf50 100644
--- a/src/tests/op_perf_test.cc
+++ b/src/tests/op_perf_test.cc
@@ -165,8 +165,8 @@ namespace {
 
     void OpTest_Spin::contract()
     {
-	MultiArray<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,SR,SR,SR,SR,SR,SR,SR,SR> ma( sr, sr, sr, sr, sr, sr, sr, sr, data);
+	Array<double,CR,SR,SR> res1( cr, sr, sr );
 
         auto ii = 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);
 	//}
         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;
 	
 	assert( xround(res1.at(mkts(0,0,0))) == xround(vres[0]) );
@@ -251,9 +251,9 @@ namespace {
 #ifndef ONLY_SPIN    
     void OpTest_Performance::PCheck()
     {
-	MultiArray<double,MRange> ma2(mrptr, cv2);
-	MultiArray<double,SRange> ma1(sr1ptr, cv1);
-	MultiArray<double,MRange> res(mrptr);
+	Array<double,MRange> ma2(mrptr, cv2);
+	Array<double,SRange> ma1(sr1ptr, cv1);
+	Array<double,MRange> res(mrptr);
 
 	auto si1 = MAT::getIndex(sr1ptr);
 	auto si2 = MAT::getIndex(sr2ptr);
@@ -265,7 +265,7 @@ namespace {
 	res(mi) = ma2(mi) * ma1(si1);
 
 	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;
 
 	vector<double> res2(vs1*vs2);
diff --git a/src/tests/op_unit_test.cc b/src/tests/op_unit_test.cc
index c0d0e5d..61e8e8c 100644
--- a/src/tests/op_unit_test.cc
+++ b/src/tests/op_unit_test.cc
@@ -35,7 +35,7 @@ namespace
 	typedef MRF::oType MRange;
 
 	typedef AnonymousRange ANO;
-	typedef MultiArray<double,ANO> AMA;
+	typedef Array<double,ANO> AMA;
 	
 	OpTest_MDim()
 	{
@@ -77,9 +77,9 @@ namespace
 
     TEST_F(OpTest_1Dim, ExecOp)
     {
-	MultiArray<double,SRange> ma1(srptr, v1);
-	MultiArray<double,SRange> ma2(srptr, v2);
-	MultiArray<double,SRange> res(srptr);
+	Array<double,SRange> ma1(srptr, v1);
+	Array<double,SRange> ma2(srptr, v2);
+	Array<double,SRange> res(srptr);
 
 	auto i = MAT::getIndex( srptr );
 	
@@ -94,10 +94,10 @@ namespace
     
     TEST_F(OpTest_MDim, ExecOp1)
     {
-	MultiArray<double,SRange,SRange> res(sr2ptr,sr4ptr);
-	MultiArray<double,SRange,SRange> res2(sr2ptr,sr4ptr);
-	const MultiArray<double,SRange> ma1(sr2ptr, v1);
-	const MultiArray<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange,SRange> res(sr2ptr,sr4ptr);
+	Array<double,SRange,SRange> res2(sr2ptr,sr4ptr);
+	const Array<double,SRange> ma1(sr2ptr, v1);
+	const Array<double,SRange> ma2(sr4ptr, v2);
 
 	auto i1 = MAT::getIndex( sr2ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -127,9 +127,9 @@ namespace
 
     TEST_F(OpTest_MDim, ExecContract)
     {
-	MultiArray<double,SRange> res(sr2ptr);
-	const MultiArray<double,SRange> ma1(sr2ptr, v1);
-	const MultiArray<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange> res(sr2ptr);
+	const Array<double,SRange> ma1(sr2ptr, v1);
+	const Array<double,SRange> ma2(sr4ptr, v2);
 
 	auto i1 = MAT::getIndex( sr2ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -143,10 +143,10 @@ namespace
     
     TEST_F(OpTest_MDim, ExecOp2)
     {
-	MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr);
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,SRange> ma2(sr4ptr, v2);
-	MultiArray<double,SRange> ma3(sr4ptr, v4);
+	Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange> ma3(sr4ptr, v4);
 	
 	auto i1 = MAT::getIndex( mr1ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -171,10 +171,10 @@ namespace
 
     TEST_F(OpTest_MDim, ExecOpAnon)
     {
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,AnonymousRange> maa
-	    = *std::dynamic_pointer_cast<MultiArray<double,AnonymousRange>>( ma1.anonymous() );
-	MultiArray<double,AnonymousRange> maa2( maa.template getRangePtr<0>() );
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,AnonymousRange> maa
+	    = *std::dynamic_pointer_cast<Array<double,AnonymousRange>>( ma1.anonymous() );
+	Array<double,AnonymousRange> maa2( maa.template getRangePtr<0>() );
 
 	auto ar = maa.template getRangePtr<0>();
 	auto i1 = MAT::getIndex( ar );
@@ -188,10 +188,10 @@ namespace
     
     TEST_F(OpTest_MDim, ExecFOp)
     {
-	MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr);
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,SRange> ma2(sr4ptr, v2);
-	MultiArray<double,SRange> ma3(sr4ptr, v4);
+	Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,SRange> ma2(sr4ptr, v2);
+	Array<double,SRange> ma3(sr4ptr, v4);
 	
 	auto i1 = MAT::getIndex( mr1ptr );
 	auto i2 = MAT::getIndex( sr4ptr );
@@ -216,13 +216,13 @@ namespace
 
     TEST_F(OpTest_MDim, ExecDOp)
     {
-	//typedef MultiArray<double,AnonymousRange> AMA;
-	typedef MultiArray<double,DynamicRange> DMA;
+	//typedef Array<double,AnonymousRange> AMA;
+	typedef Array<double,DynamicRange> DMA;
 	
-	MultiArray<double,MRange,SRange> ma1(mr1ptr,sr4ptr,v5);
-	MultiArray<double,SRange> ma2(sr2ptr,v1);
-	MultiArray<double,SRange,MRange> res(sr4ptr,mr1ptr);
-	MultiArray<double,MRange,SRange> res2(mr1ptr,sr4ptr);
+	Array<double,MRange,SRange> ma1(mr1ptr,sr4ptr,v5);
+	Array<double,SRange> ma2(sr2ptr,v1);
+	Array<double,SRange,MRange> res(sr4ptr,mr1ptr);
+	Array<double,MRange,SRange> res2(mr1ptr,sr4ptr);
 
 	DMA dma1 = *std::dynamic_pointer_cast<DMA>( dynamic( ma1 ) );
 	DMA dma2 = *std::dynamic_pointer_cast<DMA>( dynamic( ma2 ) );
@@ -285,13 +285,13 @@ namespace
 
     TEST_F(OpTest_MDim, ExecOp3)
     {
-	MultiArray<double,MRange,SRange> res(mr1ptr,sr4ptr);
-	MultiArray<double,MRange> ma1(mr1ptr, v3);
-	MultiArray<double,SRange> ma2(sr2ptr, v1);
-	MultiArray<double,SRange> ma3(sr4ptr, v4);
-	MultiArray<double,SRange,SRange,SRange,SRange> ma4(sr1ptr,sr2ptr,sr3ptr,sr4ptr);
-	MultiArray<double,SRange> ma5(sr1ptr, v3);
-	MultiArray<double,SRange> ma6(sr3ptr, v2);
+	Array<double,MRange,SRange> res(mr1ptr,sr4ptr);
+	Array<double,MRange> ma1(mr1ptr, v3);
+	Array<double,SRange> ma2(sr2ptr, v1);
+	Array<double,SRange> ma3(sr4ptr, v4);
+	Array<double,SRange,SRange,SRange,SRange> ma4(sr1ptr,sr2ptr,sr3ptr,sr4ptr);
+	Array<double,SRange> ma5(sr1ptr, v3);
+	Array<double,SRange> ma6(sr3ptr, v2);
 	
 	auto si0 = MAT::getIndex( sr1ptr ); // 'x'
 	auto si1 = MAT::getIndex( sr2ptr ); // '1'
@@ -324,9 +324,9 @@ namespace
 	(*si3) = 0;
 	Slice<double,SRange,SRange> sl(sr4ptr,sr3ptr);
 	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) = slb(si3,si2);