diff --git a/CMakeLists.txt b/CMakeLists.txt
index ba65885..a66ce5c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.8)
 
 project(multi_array)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -std=c++11 -Wpedantic -O3 -g -march=native -fopenmp")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -std=c++11 -Wpedantic -O3 -g -march=native -fopenmp -funroll-loops -ftree-vectorize")
 
 enable_testing()
 
diff --git a/src/include/ranges/anonymous_range.h b/src/include/ranges/anonymous_range.h
index 4cfb980..0099258 100644
--- a/src/include/ranges/anonymous_range.h
+++ b/src/include/ranges/anonymous_range.h
@@ -14,12 +14,12 @@
 namespace MultiArrayTools
 {
 
-    typedef SingleIndex<size_t,SpaceType::ANON> AnonymousIndex;
+    typedef GenSingleIndex<size_t,SpaceType::ANON,-1> AnonymousIndex;
 
     //template <class R>
     //using SIZET = size_t;
 
-    typedef SingleRange<size_t,SpaceType::ANON> AnonymousRange;
+    typedef GenSingleRange<size_t,SpaceType::ANON,-1> AnonymousRange;
     
     // NOT THREAD SAVE!!
     class AnonymousRangeFactory : public RangeFactoryBase
@@ -53,7 +53,7 @@ namespace MultiArrayTools
     };
 
     template <>
-    class SingleRange<size_t,SpaceType::ANON> : public RangeInterface<AnonymousIndex>
+    class GenSingleRange<size_t,SpaceType::ANON,-1> : public RangeInterface<AnonymousIndex>
     {
     public:
 
@@ -64,7 +64,7 @@ namespace MultiArrayTools
 	
 	typedef RangeBase RB;
 	typedef typename RangeInterface<AnonymousIndex>::IndexType IndexType;
-	typedef SingleRange<size_t,SpaceType::ANON> RangeType;
+	typedef GenSingleRange<size_t,SpaceType::ANON,-1> RangeType;
 	typedef size_t MetaType;
 	
 	virtual size_t size() const final;
@@ -105,16 +105,16 @@ namespace MultiArrayTools
 	
     protected:
 
-	SingleRange() = default;
-	SingleRange(const AnonymousRange& in) = default;
+	GenSingleRange() = default;
+	GenSingleRange(const AnonymousRange& in) = default;
 
 	template <class... RangeTypes>
-	SingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs);
+	GenSingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs);
 	
 	template <class... RangeTypes>
-	SingleRange(std::shared_ptr<RangeTypes>... origs);
+	GenSingleRange(std::shared_ptr<RangeTypes>... origs);
 
-	SingleRange(const std::vector<std::shared_ptr<RangeBase>>& origs);
+	GenSingleRange(const std::vector<std::shared_ptr<RangeBase>>& origs);
 	
 	size_t mSize = 1;
 	bool mEmpty = true;
@@ -203,7 +203,7 @@ namespace MultiArrayTools
      ***********************/
 
     template <class... RangeTypes>
-    SingleRange<size_t,SpaceType::ANON>::SingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
+    GenSingleRange<size_t,SpaceType::ANON,-1>::GenSingleRange(const std::tuple<std::shared_ptr<RangeTypes>...>& origs) :
 	RangeInterface<AnonymousIndex>()
     {
 	RPackNum<sizeof...(RangeTypes)-1>::RangesToVec( origs, mOrig );
@@ -214,7 +214,7 @@ namespace MultiArrayTools
     }
     
     template <class... RangeTypes>
-    SingleRange<size_t,SpaceType::ANON>::SingleRange(std::shared_ptr<RangeTypes>... origs) :
+    GenSingleRange<size_t,SpaceType::ANON,-1>::GenSingleRange(std::shared_ptr<RangeTypes>... origs) :
 	RangeInterface<AnonymousIndex>()
     {
 	auto rst = std::make_tuple(origs...);
@@ -226,13 +226,13 @@ namespace MultiArrayTools
     }
    
     template <class Range>
-    std::shared_ptr<Range> SingleRange<size_t,SpaceType::ANON>::fullsub(size_t num) const
+    std::shared_ptr<Range> GenSingleRange<size_t,SpaceType::ANON,-1>::fullsub(size_t num) const
     {
 	return std::dynamic_pointer_cast<Range>( mOrig.at(num) );
     }
 
     template <class... Ranges>
-    std::shared_ptr<MultiRange<Ranges...> > SingleRange<size_t,SpaceType::ANON>::scast(SIZET<Ranges>... sizes) const
+    std::shared_ptr<MultiRange<Ranges...> > GenSingleRange<size_t,SpaceType::ANON,-1>::scast(SIZET<Ranges>... sizes) const
     {
 	std::tuple<std::shared_ptr<Ranges>...> rtp;
 	RPackNum<sizeof...(Ranges)-1>::resolveRangeType(mOrig, rtp, 0, sizes...);
diff --git a/src/include/ranges/range_types/classic_range.h b/src/include/ranges/range_types/classic_range.h
index 3a65fea..f9b4ed6 100644
--- a/src/include/ranges/range_types/classic_range.h
+++ b/src/include/ranges/range_types/classic_range.h
@@ -12,29 +12,29 @@
 
 namespace MultiArrayTools
 {
-    typedef SingleIndex<size_t,SpaceType::NONE> ClassicIndex;
+    typedef GenSingleIndex<size_t,SpaceType::NONE,-1> ClassicIndex;
 
     template <>
-    class SingleRangeFactory<size_t,SpaceType::NONE> : public RangeFactoryBase
+    class GenSingleRangeFactory<size_t,SpaceType::NONE,-1> : public RangeFactoryBase
     {
     public:
 	
-	typedef SingleRange<size_t,SpaceType::NONE> oType;
+	typedef GenSingleRange<size_t,SpaceType::NONE,-1> oType;
 
-	SingleRangeFactory(size_t size = 0);
+	GenSingleRangeFactory(size_t size = 0);
 	std::shared_ptr<RangeBase> create();
 	
     };
 
     template <>
-    class SingleRange<size_t,SpaceType::NONE> : public RangeInterface<ClassicIndex>
+    class GenSingleRange<size_t,SpaceType::NONE,-1> : public RangeInterface<ClassicIndex>
     {
     public:
 	typedef RangeBase RB;
-	typedef typename RangeInterface<SingleIndex<size_t,SpaceType::NONE> >::IndexType IndexType;
-	typedef SingleRange<size_t,SpaceType::NONE> RangeType;
+	typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::NONE,-1> >::IndexType IndexType;
+	typedef GenSingleRange<size_t,SpaceType::NONE,-1> RangeType;
 	typedef size_t MetaType;
-        typedef SingleRangeFactory<size_t,SpaceType::NONE> FType; 
+        typedef GenSingleRangeFactory<size_t,SpaceType::NONE,-1> FType; 
         
 	virtual size_t size() const final;
 	virtual size_t dim() const final;
@@ -52,28 +52,28 @@ namespace MultiArrayTools
 	virtual IndexType end() const final;
 	//virtual std::shared_ptr<VIWB> index() const final;
 	
-	friend SingleRangeFactory<size_t,SpaceType::NONE>;
+	friend GenSingleRangeFactory<size_t,SpaceType::NONE,-1>;
 
 	static constexpr bool defaultable = true;
 	static constexpr size_t ISSTATIC = 0;
 	static constexpr size_t SIZE = -1;
 	static constexpr bool HASMETACONT = false;
 	
-	static SingleRangeFactory<size_t, SpaceType::NONE> factory(size_t size = 0)
-	{ return SingleRangeFactory<size_t, SpaceType::NONE>(size); }
+	static GenSingleRangeFactory<size_t,SpaceType::NONE,-1> factory(size_t size = 0)
+	{ return GenSingleRangeFactory<size_t,SpaceType::NONE,-1>(size); }
 	
     protected:
 
 	size_t mSize = 0; 
 	
-	SingleRange() = default;
-	SingleRange(const SingleRange& in) = delete;
+	GenSingleRange() = default;
+	GenSingleRange(const GenSingleRange& in) = delete;
 
-	SingleRange(size_t size);
+	GenSingleRange(size_t size);
     };
 
-    typedef SingleRange<size_t,SpaceType::NONE> ClassicRange;
-    typedef SingleRangeFactory<size_t,SpaceType::NONE> ClassicRF;
+    typedef GenSingleRange<size_t,SpaceType::NONE,-1> ClassicRange;
+    typedef GenSingleRangeFactory<size_t,SpaceType::NONE,-1> ClassicRF;
 }
 
 
diff --git a/src/include/ranges/range_types/null_range.h b/src/include/ranges/range_types/null_range.h
index 968c0c0..994bb29 100644
--- a/src/include/ranges/range_types/null_range.h
+++ b/src/include/ranges/range_types/null_range.h
@@ -12,19 +12,19 @@ include_range_type(NUL,-2)
 
 namespace MultiArrayTools
 {   
-    typedef SingleIndex<size_t,SpaceType::NUL> NullIndex;
+    typedef GenSingleIndex<size_t,SpaceType::NUL,0> NullIndex;
 
-    std::shared_ptr<SingleRange<size_t,SpaceType::NUL> > nullr();
+    std::shared_ptr<GenSingleRange<size_t,SpaceType::NUL,0> > nullr();
     std::shared_ptr<NullIndex> nulli();
 
     template <>
-    class SingleRangeFactory<size_t,SpaceType::NUL> : public RangeFactoryBase
+    class GenSingleRangeFactory<size_t,SpaceType::NUL,0> : public RangeFactoryBase
     {
     public:
 	
-	typedef SingleRange<size_t,SpaceType::NUL> oType;
+	typedef GenSingleRange<size_t,SpaceType::NUL,0> oType;
 
-	SingleRangeFactory();
+	GenSingleRangeFactory();
 	std::shared_ptr<RangeBase> create();
 
 	friend std::shared_ptr<oType> nullr();
@@ -34,14 +34,14 @@ namespace MultiArrayTools
     };
 
     template <>
-    class SingleRange<size_t,SpaceType::NUL> : public RangeInterface<NullIndex>
+    class GenSingleRange<size_t,SpaceType::NUL,0> : public RangeInterface<NullIndex>
     {
     public:
 	typedef RangeBase RB;
-	typedef typename RangeInterface<SingleIndex<size_t,SpaceType::NUL> >::IndexType IndexType;
-	typedef SingleRange<size_t,SpaceType::NUL> RangeType;
+	typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::NUL,0> >::IndexType IndexType;
+	typedef GenSingleRange<size_t,SpaceType::NUL,0> RangeType;
 	typedef size_t MetaType;
-        typedef SingleRangeFactory<size_t,SpaceType::NUL> FType; 
+        typedef GenSingleRangeFactory<size_t,SpaceType::NUL,0> FType; 
 	
 	virtual size_t size() const final;
 	virtual size_t dim() const final;
@@ -59,7 +59,7 @@ namespace MultiArrayTools
 	virtual IndexType end() const final;
 	//virtual std::shared_ptr<VIWB> index() const final;
 	
-	friend SingleRangeFactory<size_t,SpaceType::NUL>;
+	friend GenSingleRangeFactory<size_t,SpaceType::NUL,0>;
 
 	static constexpr bool defaultable = true;
 
@@ -67,19 +67,19 @@ namespace MultiArrayTools
 	static constexpr size_t SIZE = 1;
 	static constexpr bool HASMETACONT = false;
 	
-	static SingleRangeFactory<size_t,SpaceType::NUL> factory()
-	{ return SingleRangeFactory<size_t,SpaceType::NUL>(); }
+	static GenSingleRangeFactory<size_t,SpaceType::NUL,0> factory()
+	{ return GenSingleRangeFactory<size_t,SpaceType::NUL,0>(); }
 	
     protected:
 
-	SingleRange() = default;
-	SingleRange(const SingleRange& in) = delete;
+	GenSingleRange() = default;
+	GenSingleRange(const GenSingleRange& in) = delete;
 
-	//SingleRange(size_t spinNum);
+	//GenSingleRange(size_t spinNum);
     };
 
-    typedef SingleRange<size_t,SpaceType::NUL> NullRange;
-    typedef SingleRangeFactory<size_t,SpaceType::NUL> NullRF;
+    typedef GenSingleRange<size_t,SpaceType::NUL,0> NullRange;
+    typedef GenSingleRangeFactory<size_t,SpaceType::NUL,0> NullRF;
     
     std::shared_ptr<NullRF> mkNUL(const char* dp, size_t size);
 	
diff --git a/src/include/ranges/range_types/space_range.h b/src/include/ranges/range_types/space_range.h
index 238afb5..46d660a 100644
--- a/src/include/ranges/range_types/space_range.h
+++ b/src/include/ranges/range_types/space_range.h
@@ -11,29 +11,29 @@ include_range_type(PSPACE,3) // Periodic 1dim space
 namespace MultiArrayTools
 {
      // Periodic 1dim space
-    typedef SingleIndex<int,SpaceType::PSPACE> XSpaceIndex;
+    typedef GenSingleIndex<int,SpaceType::PSPACE,-1> XSpaceIndex;
 
     template <>
-    class SingleRangeFactory<int,SpaceType::PSPACE> : public RangeFactoryBase
+    class GenSingleRangeFactory<int,SpaceType::PSPACE,-1> : public RangeFactoryBase
     {
     public:
 	
-	typedef SingleRange<int,SpaceType::PSPACE> oType;
+	typedef GenSingleRange<int,SpaceType::PSPACE,-1> oType;
 
-	SingleRangeFactory(size_t size = 0);
+	GenSingleRangeFactory(size_t size = 0);
 	std::shared_ptr<RangeBase> create();
 	
     };
     
     template <>
-    class SingleRange<int,SpaceType::PSPACE> : public RangeInterface<XSpaceIndex>
+    class GenSingleRange<int,SpaceType::PSPACE,-1> : public RangeInterface<XSpaceIndex>
     {
     public:
 	typedef RangeBase RB;
-	typedef typename RangeInterface<SingleIndex<int,SpaceType::PSPACE> >::IndexType IndexType;
-	typedef SingleRange<int,SpaceType::PSPACE> RangeType;
+	typedef typename RangeInterface<GenSingleIndex<int,SpaceType::PSPACE,-1> >::IndexType IndexType;
+	typedef GenSingleRange<int,SpaceType::PSPACE,-1> RangeType;
 	typedef int MetaType;
-        typedef SingleRangeFactory<int,SpaceType::PSPACE> FType; 
+        typedef GenSingleRangeFactory<int,SpaceType::PSPACE,-1> FType; 
 	
 	virtual size_t size() const final;
 	virtual size_t dim() const final;
@@ -50,28 +50,28 @@ namespace MultiArrayTools
 	virtual IndexType begin() const final;
 	virtual IndexType end() const final;
 	
-	friend SingleRangeFactory<int,SpaceType::PSPACE>;
+	friend GenSingleRangeFactory<int,SpaceType::PSPACE,-1>;
 
 	static constexpr bool defaultable = true;
 	static constexpr size_t ISSTATIC = 0;
 	static constexpr size_t SIZE = -1;
 	static constexpr bool HASMETACONT = false;
 	
-	static SingleRangeFactory<int, SpaceType::PSPACE> factory(size_t size = 0)
-	{ return SingleRangeFactory<int, SpaceType::PSPACE>(size); }
+	static GenSingleRangeFactory<int,SpaceType::PSPACE,-1> factory(size_t size = 0)
+	{ return GenSingleRangeFactory<int,SpaceType::PSPACE,-1>(size); }
 	
     protected:
 
 	size_t mSize = 0;
 	
-	SingleRange() = default;
-	SingleRange(const SingleRange& in) = delete;
+	GenSingleRange() = default;
+	GenSingleRange(const GenSingleRange& in) = delete;
 	
-	SingleRange(size_t size);
+	GenSingleRange(size_t size);
     };
 
-    typedef SingleRange<int,SpaceType::PSPACE> PSpaceRange;
-    typedef SingleRangeFactory<int,SpaceType::PSPACE> PSpaceRF;
+    typedef GenSingleRange<int,SpaceType::PSPACE,-1> PSpaceRange;
+    typedef GenSingleRangeFactory<int,SpaceType::PSPACE,-1> PSpaceRF;
 
     std::shared_ptr<PSpaceRF> mkPSPACE(const char* dp, size_t size);
     
diff --git a/src/include/ranges/range_types/spin_range.h b/src/include/ranges/range_types/spin_range.h
index 32c8dff..97992b5 100644
--- a/src/include/ranges/range_types/spin_range.h
+++ b/src/include/ranges/range_types/spin_range.h
@@ -12,29 +12,29 @@ include_range_type(SPIN,2)
 
 namespace MultiArrayTools
 {
-    typedef SingleIndex<size_t,SpaceType::SPIN> SpinIndex;
+    typedef GenSingleIndex<size_t,SpaceType::SPIN,4> SpinIndex;
 
     template <>
-    class SingleRangeFactory<size_t,SpaceType::SPIN> : public RangeFactoryBase
+    class GenSingleRangeFactory<size_t,SpaceType::SPIN,4> : public RangeFactoryBase
     {
     public:
 	
-	typedef SingleRange<size_t,SpaceType::SPIN> oType;
+	typedef GenSingleRange<size_t,SpaceType::SPIN,4> oType;
 
-	SingleRangeFactory();
+	GenSingleRangeFactory();
 	std::shared_ptr<RangeBase> create();
 	
     };
 
     template <>
-    class SingleRange<size_t,SpaceType::SPIN> : public RangeInterface<SpinIndex>
+    class GenSingleRange<size_t,SpaceType::SPIN,4> : public RangeInterface<SpinIndex>
     {
     public:
 	typedef RangeBase RB;
-	typedef typename RangeInterface<SingleIndex<size_t,SpaceType::SPIN> >::IndexType IndexType;
-	typedef SingleRange<size_t,SpaceType::SPIN> RangeType;
+	typedef typename RangeInterface<GenSingleIndex<size_t,SpaceType::SPIN,4> >::IndexType IndexType;
+	typedef GenSingleRange<size_t,SpaceType::SPIN,4> RangeType;
 	typedef size_t MetaType;
-        typedef SingleRangeFactory<size_t,SpaceType::SPIN> FType; 
+        typedef GenSingleRangeFactory<size_t,SpaceType::SPIN,4> FType; 
         
 	virtual size_t size() const final;
 	virtual size_t dim() const final;
@@ -52,7 +52,7 @@ namespace MultiArrayTools
 	virtual IndexType end() const final;
 	//virtual std::shared_ptr<VIWB> index() const final;
 	
-	friend SingleRangeFactory<size_t,SpaceType::SPIN>;
+	friend GenSingleRangeFactory<size_t,SpaceType::SPIN,4>;
 
 	static constexpr bool defaultable = true;
 	static constexpr size_t mSpinNum = 4;
@@ -61,19 +61,19 @@ namespace MultiArrayTools
 	static constexpr size_t SIZE = mSpinNum;
 	static constexpr bool HASMETACONT = false;
 	
-	static SingleRangeFactory<size_t, SpaceType::SPIN> factory()
-	{ return SingleRangeFactory<size_t, SpaceType::SPIN>(); }
+	static GenSingleRangeFactory<size_t,SpaceType::SPIN,4> factory()
+	{ return GenSingleRangeFactory<size_t,SpaceType::SPIN,4>(); }
 	
     protected:
 
-	SingleRange() = default;
-	SingleRange(const SingleRange& in) = delete;
+	GenSingleRange() = default;
+	GenSingleRange(const GenSingleRange& in) = delete;
 
-	//SingleRange(size_t spinNum);
+	//GenSingleRange(size_t spinNum);
     };
 
-    typedef SingleRange<size_t,SpaceType::SPIN> SpinRange;
-    typedef SingleRangeFactory<size_t,SpaceType::SPIN> SpinRF;
+    typedef GenSingleRange<size_t,SpaceType::SPIN,4> SpinRange;
+    typedef GenSingleRangeFactory<size_t,SpaceType::SPIN,4> SpinRF;
 
     std::shared_ptr<SpinRF> mkSPIN(const char* dp, size_t size);
 }
diff --git a/src/include/ranges/rbase_def.h b/src/include/ranges/rbase_def.h
index 3cffe08..64ccc45 100644
--- a/src/include/ranges/rbase_def.h
+++ b/src/include/ranges/rbase_def.h
@@ -44,16 +44,16 @@ namespace MultiArrayTools
     class IndexInterface;
 
     // single_range.h    
-    template <typename U, SpaceType TYPE>
-    class SingleRange;
+    template <typename U, SpaceType TYPE, size_t S>
+    class GenSingleRange;
 
     // single_range.h    
-    template <typename U, SpaceType TYPE>
-    class SingleRangeFactory;
+    template <typename U, SpaceType TYPE, size_t S>
+    class GenSingleRangeFactory;
 
     // single_range.h
-    template <typename U, SpaceType TYPE>
-    class SingleIndex;
+    template <typename U, SpaceType TYPE, size_t S>
+    class GenSingleIndex;
 
     // subrange.h
     template <class Index>
diff --git a/src/include/ranges/single_range.h b/src/include/ranges/single_range.h
index 1affcaf..57d76f7 100644
--- a/src/include/ranges/single_range.h
+++ b/src/include/ranges/single_range.h
@@ -28,19 +28,19 @@ namespace MultiArrayTools
     }
 
     
-    template <typename U, SpaceType TYPE>
-    class SingleIndex : public IndexInterface<SingleIndex<U,TYPE>,U>
+    template <typename U, SpaceType TYPE, size_t S>
+    class GenSingleIndex : public IndexInterface<GenSingleIndex<U,TYPE,S>,U>
     {
     public:
 
-	typedef IndexInterface<SingleIndex<U,TYPE>,U> IB;
+	typedef IndexInterface<GenSingleIndex<U,TYPE,S>,U> IB;
 	typedef U MetaType;
-	typedef SingleRange<U,TYPE> RangeType;
-	typedef SingleIndex IType;
+	typedef GenSingleRange<U,TYPE,S> RangeType;
+	typedef GenSingleIndex IType;
 
-	//DEFAULT_MEMBERS_X(SingleIndex);
+	//DEFAULT_MEMBERS_X(GenSingleIndex);
 	
-	SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range);
+	GenSingleIndex(const std::shared_ptr<GenSingleRange<U,TYPE,S> >& range);
 
 	static constexpr IndexType sType() { return IndexType::SINGLE; }
 	static constexpr size_t totalDim() { return 1; }
@@ -53,9 +53,9 @@ namespace MultiArrayTools
 	
 	IndexType type() const;
 	
-	SingleIndex& operator=(size_t pos);
-	SingleIndex& operator++();
-	SingleIndex& operator--();
+	GenSingleIndex& operator=(size_t pos);
+	GenSingleIndex& operator++();
+	GenSingleIndex& operator--();
 
 	int pp(std::intptr_t idxPtrNum);
 	int mm(std::intptr_t idxPtrNum);
@@ -63,7 +63,7 @@ namespace MultiArrayTools
 	std::string stringMeta() const;
 	U meta() const;
 	const U* metaPtr() const;
-	SingleIndex& at(const U& metaPos);
+	GenSingleIndex& at(const U& metaPos);
 	size_t posAt(const U& metaPos) const;
 
 	bool isMeta(const U& metaPos) const;
@@ -84,30 +84,30 @@ namespace MultiArrayTools
 
 	template <class Expr>
 	auto ifor(size_t step, Expr ex) const
-	    -> For<SingleIndex<U,TYPE>,Expr>;
+	    -> For<GenSingleIndex<U,TYPE,S>,Expr>;
 
 	template <class Expr>
 	auto iforh(size_t step, Expr ex) const
-	    -> For<SingleIndex<U,TYPE>,Expr,ForType::HIDDEN>;
+	    -> For<GenSingleIndex<U,TYPE,S>,Expr,ForType::HIDDEN>;
 
         template <class Expr>
 	auto pifor(size_t step, Expr ex) const
-	    -> PFor<SingleIndex<U,TYPE>,Expr>;
+	    -> PFor<GenSingleIndex<U,TYPE,S>,Expr>;
         
     private:
 	std::shared_ptr<RangeType> mExplicitRangePtr;
 	const U* mMetaPtr;
     };
 
-    template <typename U, SpaceType TYPE>
-    class SingleRangeFactory : public RangeFactoryBase
+    template <typename U, SpaceType TYPE, size_t S>
+    class GenSingleRangeFactory : public RangeFactoryBase
     {
     public:
 	
-	typedef SingleRange<U,TYPE> oType;
+	typedef GenSingleRange<U,TYPE,S> oType;
 
-	SingleRangeFactory() = delete;
-	SingleRangeFactory(const std::vector<U>& space);
+	GenSingleRangeFactory() = delete;
+	GenSingleRangeFactory(const std::vector<U>& space);
 	std::shared_ptr<RangeBase> create();
 	
     };
@@ -186,17 +186,31 @@ namespace MultiArrayTools
 	}
 	
     };
-    
-    template <typename U, SpaceType TYPE>
-    class SingleRange : public RangeInterface<SingleIndex<U,TYPE> >
+
+    template <size_t S>
+    struct CheckStatic
+    {
+        static constexpr size_t ISSTATIC = true;
+        static constexpr size_t SIZE = S;
+    };
+
+    template <>
+    struct CheckStatic<-1>
+    {
+        static constexpr size_t ISSTATIC = false;
+        static constexpr size_t SIZE = -1;
+    };
+
+    template <typename U, SpaceType TYPE, size_t S>
+    class GenSingleRange : public RangeInterface<GenSingleIndex<U,TYPE,S> >
     {
     public:
 	typedef RangeBase RB;
-	typedef SingleIndex<U,TYPE> IndexType;
-	typedef SingleRange RangeType;
+	typedef GenSingleIndex<U,TYPE,S> IndexType;
+	typedef GenSingleRange RangeType;
 	typedef U MetaType;
-	typedef SingleRangeFactory<U,TYPE> FType; 
-	//typedef typename RangeInterface<SingleIndex<U,TYPE> >::IndexType IndexType;
+	typedef GenSingleRangeFactory<U,TYPE,S> FType; 
+	//typedef typename RangeInterface<GenSingleIndex<U,TYPE,S> >::IndexType IndexType;
 	
 	virtual size_t size() const final;
 	virtual size_t dim() const final;
@@ -215,25 +229,34 @@ namespace MultiArrayTools
 	virtual IndexType begin() const final;
 	virtual IndexType end() const final;
 		
-	friend SingleRangeFactory<U,TYPE>;
+	friend GenSingleRangeFactory<U,TYPE,S>;
 
 	static constexpr bool defaultable = false;
-	static constexpr size_t ISSTATIC = 0;
-	static constexpr size_t SIZE = -1;
+	static constexpr size_t ISSTATIC = CheckStatic<S>::ISSTATIC;
+	static constexpr size_t SIZE = CheckStatic<S>::SIZE;
 	static constexpr bool HASMETACONT = true;
 	
     protected:
 
-	SingleRange() = delete;
-	SingleRange(const SingleRange& in) = delete;
+	GenSingleRange() = delete;
+	GenSingleRange(const GenSingleRange& in) = delete;
 	
-	SingleRange(const std::vector<U>& space);
+	GenSingleRange(const std::vector<U>& space);
 
 	std::vector<U> mSpace;
 	//std::map<U,size_t> mMSpace;
 	MetaMap<U> mMSpace;
     };
 
+    template <typename U, SpaceType TYPE>
+    using SingleRange = GenSingleRange<U,TYPE,-1>;
+
+    template <typename U, SpaceType TYPE>
+    using SingleIndex = GenSingleIndex<U,TYPE,-1>;
+
+    template <typename U, SpaceType TYPE>
+    using SingleRangeFactory = GenSingleRangeFactory<U,TYPE,-1>;
+
 }
 
 /* ========================= *
@@ -243,7 +266,7 @@ namespace MultiArrayTools
 namespace MultiArrayTools
 {
     /******************
-     *  SingleIndex   *	     
+     *  GenSingleIndex   *	     
      ******************/
 
     template <bool HASMETACONT>
@@ -278,134 +301,134 @@ namespace MultiArrayTools
 	}
     };
 
-    template <typename U, SpaceType TYPE>
-    SingleIndex<U,TYPE>::SingleIndex(const std::shared_ptr<SingleRange<U,TYPE> >& range) :
-	IndexInterface<SingleIndex<U,TYPE>,U>(range, 0),
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleIndex<U,TYPE,S>::GenSingleIndex(const std::shared_ptr<GenSingleRange<U,TYPE,S> >& range) :
+	IndexInterface<GenSingleIndex<U,TYPE,S>,U>(range, 0),
 	mExplicitRangePtr(std::dynamic_pointer_cast<RangeType>(IB::mRangePtr)),
-	mMetaPtr(MetaPtrHandle<SingleIndex<U,TYPE>::RangeType::HASMETACONT>::set
+	mMetaPtr(MetaPtrHandle<GenSingleIndex<U,TYPE,S>::RangeType::HASMETACONT>::set
 		 ( dynamic_cast<RangeType*>(IB::mRangePtr.get() ) ) ) {}
 
-    template <typename U, SpaceType TYPE>
-    IndexType SingleIndex<U,TYPE>::type() const
+    template <typename U, SpaceType TYPE, size_t S>
+    IndexType GenSingleIndex<U,TYPE,S>::type() const
     {
 	return IndexType::SINGLE;
     }
 
-    template <typename U, SpaceType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator=(size_t pos)
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleIndex<U,TYPE,S>& GenSingleIndex<U,TYPE,S>::operator=(size_t pos)
     {
 	IB::mPos = pos;
 	return *this;
     }
 
-    template <typename U, SpaceType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator++()
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleIndex<U,TYPE,S>& GenSingleIndex<U,TYPE,S>::operator++()
     {
 	++IB::mPos;
 	return *this;
     }
 
-    template <typename U, SpaceType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::operator--()
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleIndex<U,TYPE,S>& GenSingleIndex<U,TYPE,S>::operator--()
     {
 	--IB::mPos;
 	return *this;
     }
 
-    template <typename U, SpaceType TYPE>
-    int SingleIndex<U,TYPE>::pp(std::intptr_t idxPtrNum)
+    template <typename U, SpaceType TYPE, size_t S>
+    int GenSingleIndex<U,TYPE,S>::pp(std::intptr_t idxPtrNum)
     {
 	++(*this);
 	return 1;
     }
 
-    template <typename U, SpaceType TYPE>
-    int SingleIndex<U,TYPE>::mm(std::intptr_t idxPtrNum)
+    template <typename U, SpaceType TYPE, size_t S>
+    int GenSingleIndex<U,TYPE,S>::mm(std::intptr_t idxPtrNum)
     {
 	--(*this);
 	return 1;
     }
 
-    template <typename U, SpaceType TYPE>
-    std::string SingleIndex<U,TYPE>::stringMeta() const
+    template <typename U, SpaceType TYPE, size_t S>
+    std::string GenSingleIndex<U,TYPE,S>::stringMeta() const
     {
-	return std::dynamic_pointer_cast<SingleRange<U,TYPE> const>( IB::mRangePtr )->stringMeta(IB::mPos);
+	return std::dynamic_pointer_cast<GenSingleRange<U,TYPE,S> const>( IB::mRangePtr )->stringMeta(IB::mPos);
     }
     
-    template <typename U, SpaceType TYPE>
-    U SingleIndex<U,TYPE>::meta() const
+    template <typename U, SpaceType TYPE, size_t S>
+    U GenSingleIndex<U,TYPE,S>::meta() const
     {
-	return MetaPtrHandle<SingleIndex<U,TYPE>::RangeType::HASMETACONT>::getMeta
+	return MetaPtrHandle<GenSingleIndex<U,TYPE,S>::RangeType::HASMETACONT>::getMeta
 	    ( mMetaPtr, IB::mPos, mExplicitRangePtr );
     }
 
-    template <typename U, SpaceType TYPE>
-    const U* SingleIndex<U,TYPE>::metaPtr() const
+    template <typename U, SpaceType TYPE, size_t S>
+    const U* GenSingleIndex<U,TYPE,S>::metaPtr() const
     {
 	return mMetaPtr;
     }
 
-    template <typename U, SpaceType TYPE>
-    bool SingleIndex<U,TYPE>::isMeta(const U& metaPos) const
+    template <typename U, SpaceType TYPE, size_t S>
+    bool GenSingleIndex<U,TYPE,S>::isMeta(const U& metaPos) const
     {
 	return mExplicitRangePtr->isMeta(metaPos);
     }
     
-    template <typename U, SpaceType TYPE>
-    SingleIndex<U,TYPE>& SingleIndex<U,TYPE>::at(const U& metaPos)
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleIndex<U,TYPE,S>& GenSingleIndex<U,TYPE,S>::at(const U& metaPos)
     {
-	(*this) = std::dynamic_pointer_cast<SingleRange<U,TYPE> const>( IB::mRangePtr )->getMeta( metaPos );
+	(*this) = std::dynamic_pointer_cast<GenSingleRange<U,TYPE,S> const>( IB::mRangePtr )->getMeta( metaPos );
 	return *this;
     }
 
-    template <typename U, SpaceType TYPE>
-    size_t SingleIndex<U,TYPE>::posAt(const U& metaPos) const
+    template <typename U, SpaceType TYPE, size_t S>
+    size_t GenSingleIndex<U,TYPE,S>::posAt(const U& metaPos) const
     {
-	return std::dynamic_pointer_cast<SingleRange<U,TYPE> const>( IB::mRangePtr )->getMeta( metaPos );
+	return std::dynamic_pointer_cast<GenSingleRange<U,TYPE,S> const>( IB::mRangePtr )->getMeta( metaPos );
     }
 
-    template <typename U, SpaceType TYPE>
-    size_t SingleIndex<U,TYPE>::dim() // = 1
+    template <typename U, SpaceType TYPE, size_t S>
+    size_t GenSingleIndex<U,TYPE,S>::dim() // = 1
     {
 	return 1;
     }
 
-    template <typename U, SpaceType TYPE>
-    bool SingleIndex<U,TYPE>::last()
+    template <typename U, SpaceType TYPE, size_t S>
+    bool GenSingleIndex<U,TYPE,S>::last()
     {
 	return IB::mPos == IB::mMax - 1;
     }
 
-    template <typename U, SpaceType TYPE>
-    bool SingleIndex<U,TYPE>::first()
+    template <typename U, SpaceType TYPE, size_t S>
+    bool GenSingleIndex<U,TYPE,S>::first()
     {
 	return IB::mPos == 0;
     }
 
-    template <typename U, SpaceType TYPE>
-    std::shared_ptr<typename SingleIndex<U,TYPE>::RangeType> SingleIndex<U,TYPE>::range()
+    template <typename U, SpaceType TYPE, size_t S>
+    std::shared_ptr<typename GenSingleIndex<U,TYPE,S>::RangeType> GenSingleIndex<U,TYPE,S>::range()
     {
 	return mExplicitRangePtr;
     }
 
-    template <typename U, SpaceType TYPE>
+    template <typename U, SpaceType TYPE, size_t S>
     template <size_t N>
-    void SingleIndex<U,TYPE>::getPtr() {}
+    void GenSingleIndex<U,TYPE,S>::getPtr() {}
     
-    template <typename U, SpaceType TYPE>
-    size_t SingleIndex<U,TYPE>::getStepSize(size_t n)
+    template <typename U, SpaceType TYPE, size_t S>
+    size_t GenSingleIndex<U,TYPE,S>::getStepSize(size_t n)
     {
 	return 1;
     }
 
-    template <typename U, SpaceType TYPE>
-    std::string SingleIndex<U,TYPE>::id() const
+    template <typename U, SpaceType TYPE, size_t S>
+    std::string GenSingleIndex<U,TYPE,S>::id() const
     {
 	return std::string("sin") + std::to_string(IB::mId);
     }
 
-    template <typename U, SpaceType TYPE>
-    void SingleIndex<U,TYPE>::print(size_t offset)
+    template <typename U, SpaceType TYPE, size_t S>
+    void GenSingleIndex<U,TYPE,S>::print(size_t offset)
     {
 	if(offset == 0){
 	    std::cout << " === " << std::endl;
@@ -415,31 +438,31 @@ namespace MultiArrayTools
 		  << "](" << IB::mRangePtr << "): " << meta() << std::endl;
     }
 
-    template <typename U, SpaceType TYPE>
+    template <typename U, SpaceType TYPE, size_t S>
     template <class Expr>
-    auto SingleIndex<U,TYPE>::ifor(size_t step, Expr ex) const
-	-> For<SingleIndex<U,TYPE>,Expr>
+    auto GenSingleIndex<U,TYPE,S>::ifor(size_t step, Expr ex) const
+	-> For<GenSingleIndex<U,TYPE,S>,Expr>
     {
 	//static const size_t LAYER = typename Expr::LAYER; 
-	return For<SingleIndex<U,TYPE>,Expr>(this, step, ex);
+	return For<GenSingleIndex<U,TYPE,S>,Expr>(this, step, ex);
     }
 
-    template <typename U, SpaceType TYPE>
+    template <typename U, SpaceType TYPE, size_t S>
     template <class Expr>
-    auto SingleIndex<U,TYPE>::iforh(size_t step, Expr ex) const
-	-> For<SingleIndex<U,TYPE>,Expr,ForType::HIDDEN>
+    auto GenSingleIndex<U,TYPE,S>::iforh(size_t step, Expr ex) const
+	-> For<GenSingleIndex<U,TYPE,S>,Expr,ForType::HIDDEN>
     {
 	//static const size_t LAYER = typename Expr::LAYER; 
-	return For<SingleIndex<U,TYPE>,Expr,ForType::HIDDEN>(this, step, ex);
+	return For<GenSingleIndex<U,TYPE,S>,Expr,ForType::HIDDEN>(this, step, ex);
     }
 
-    template <typename U, SpaceType TYPE>
+    template <typename U, SpaceType TYPE, size_t S>
     template <class Expr>
-    auto SingleIndex<U,TYPE>::pifor(size_t step, Expr ex) const
-	-> PFor<SingleIndex<U,TYPE>,Expr>
+    auto GenSingleIndex<U,TYPE,S>::pifor(size_t step, Expr ex) const
+	-> PFor<GenSingleIndex<U,TYPE,S>,Expr>
     {
 	//static const size_t LAYER = typename Expr::LAYER; 
-	return PFor<SingleIndex<U,TYPE>,Expr>(this, step, ex);
+	return PFor<GenSingleIndex<U,TYPE,S>,Expr>(this, step, ex);
     }
 
     
@@ -447,14 +470,14 @@ namespace MultiArrayTools
      *   SingleRange    *
      ********************/
 
-    template <typename U, SpaceType TYPE>
-    SingleRangeFactory<U,TYPE>::SingleRangeFactory(const std::vector<U>& space)
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleRangeFactory<U,TYPE,S>::GenSingleRangeFactory(const std::vector<U>& space)
     {
-	mProd = std::shared_ptr<oType>( new SingleRange<U,TYPE>( space ) );
+	mProd = std::shared_ptr<oType>( new GenSingleRange<U,TYPE,S>( space ) );
     }
 
-    template <typename U, SpaceType TYPE>
-    std::shared_ptr<RangeBase> SingleRangeFactory<U,TYPE>::create()
+    template <typename U, SpaceType TYPE, size_t S>
+    std::shared_ptr<RangeBase> GenSingleRangeFactory<U,TYPE,S>::create()
     {
 	setSelf();
 	return mProd;
@@ -464,9 +487,9 @@ namespace MultiArrayTools
      *   SingleRange    *
      ********************/
     
-    template <typename U, SpaceType TYPE>
-    SingleRange<U,TYPE>::SingleRange(const std::vector<U>& space) :
-	RangeInterface<SingleIndex<U,TYPE> >(),
+    template <typename U, SpaceType TYPE, size_t S>
+    GenSingleRange<U,TYPE,S>::GenSingleRange(const std::vector<U>& space) :
+	RangeInterface<GenSingleIndex<U,TYPE,S> >(),
 	mSpace(space), mMSpace(mSpace)
     {
 	//for(size_t i = 0; i != mSpace.size(); ++i){
@@ -474,50 +497,50 @@ namespace MultiArrayTools
 	//}
     }
     
-    template <typename U, SpaceType TYPE>
-    const U& SingleRange<U,TYPE>::get(size_t pos) const
+    template <typename U, SpaceType TYPE, size_t S>
+    const U& GenSingleRange<U,TYPE,S>::get(size_t pos) const
     {
 	return mSpace[pos];
     }
 
-    template <typename U, SpaceType TYPE>
-    size_t SingleRange<U,TYPE>::getMeta(const U& metaPos) const
+    template <typename U, SpaceType TYPE, size_t S>
+    size_t GenSingleRange<U,TYPE,S>::getMeta(const U& metaPos) const
     {
 	return mMSpace.at(metaPos);
     }
 
-    template <typename U, SpaceType TYPE>
-    size_t SingleRange<U,TYPE>::size() const
+    template <typename U, SpaceType TYPE, size_t S>
+    size_t GenSingleRange<U,TYPE,S>::size() const
     {
 	return mSpace.size();
     }
 
-    template <typename U, SpaceType TYPE>
-    size_t SingleRange<U,TYPE>::dim() const
+    template <typename U, SpaceType TYPE, size_t S>
+    size_t GenSingleRange<U,TYPE,S>::dim() const
     {
 	return 1;
     }
 
-    template <typename U, SpaceType TYPE>
-    bool SingleRange<U,TYPE>::isMeta(const U& metaPos) const
+    template <typename U, SpaceType TYPE, size_t S>
+    bool GenSingleRange<U,TYPE,S>::isMeta(const U& metaPos) const
     {
 	return mMSpace.count(metaPos) != 0;
     }
     
-    template <typename U, SpaceType TYPE>
-    SpaceType SingleRange<U,TYPE>::spaceType() const
+    template <typename U, SpaceType TYPE, size_t S>
+    SpaceType GenSingleRange<U,TYPE,S>::spaceType() const
     {
 	return TYPE;
     }
     
-    template <typename U, SpaceType TYPE>
-    std::string SingleRange<U,TYPE>::stringMeta(size_t pos) const
+    template <typename U, SpaceType TYPE, size_t S>
+    std::string GenSingleRange<U,TYPE,S>::stringMeta(size_t pos) const
     {
 	return xToString(get(pos));
     }
 
-    template <typename U, SpaceType TYPE>
-    std::vector<char> SingleRange<U,TYPE>::data() const
+    template <typename U, SpaceType TYPE, size_t S>
+    std::vector<char> GenSingleRange<U,TYPE,S>::data() const
     {
         DataHeader h = dataHeader();
 	std::vector<char> out;
@@ -530,8 +553,8 @@ namespace MultiArrayTools
 	return out;
     }
     
-    template <typename U, SpaceType TYPE>
-    DataHeader SingleRange<U,TYPE>::dataHeader() const
+    template <typename U, SpaceType TYPE, size_t S>
+    DataHeader GenSingleRange<U,TYPE,S>::dataHeader() const
     {
 	DataHeader h;
 	h.spaceType = static_cast<int>( TYPE );
@@ -541,19 +564,19 @@ namespace MultiArrayTools
         return h;
     }
     
-    template <typename U, SpaceType TYPE>
-    typename SingleRange<U,TYPE>::IndexType SingleRange<U,TYPE>::begin() const
+    template <typename U, SpaceType TYPE, size_t S>
+    typename GenSingleRange<U,TYPE,S>::IndexType GenSingleRange<U,TYPE,S>::begin() const
     {
-	SingleIndex<U,TYPE> i( std::dynamic_pointer_cast<SingleRange<U,TYPE> >
+	GenSingleIndex<U,TYPE,S> i( std::dynamic_pointer_cast<GenSingleRange<U,TYPE,S> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = 0;
 	return i;
     }
     
-    template <typename U, SpaceType TYPE>
-    typename SingleRange<U,TYPE>::IndexType SingleRange<U,TYPE>::end() const
+    template <typename U, SpaceType TYPE, size_t S>
+    typename GenSingleRange<U,TYPE,S>::IndexType GenSingleRange<U,TYPE,S>::end() const
     {
-	SingleIndex<U,TYPE> i( std::dynamic_pointer_cast<SingleRange<U,TYPE> >
+	GenSingleIndex<U,TYPE,S> i( std::dynamic_pointer_cast<GenSingleRange<U,TYPE,S> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = size();
 	return i;
diff --git a/src/lib/ranges/anonymous_range.cc b/src/lib/ranges/anonymous_range.cc
index 3849270..4b5a337 100644
--- a/src/lib/ranges/anonymous_range.cc
+++ b/src/lib/ranges/anonymous_range.cc
@@ -196,7 +196,7 @@ namespace MultiArrayTools
         return mOrig;
     }
     
-    SingleRange<size_t,SpaceType::ANON>::SingleRange(const std::vector<std::shared_ptr<RangeBase>>& origs) :
+    GenSingleRange<size_t,SpaceType::ANON,-1>::GenSingleRange(const std::vector<std::shared_ptr<RangeBase>>& origs) :
         RangeInterface<AnonymousIndex>(),
         mOrig(origs)
     {
diff --git a/src/lib/ranges/range_types/classic_range.cc b/src/lib/ranges/range_types/classic_range.cc
index 9cdba7d..db147d9 100644
--- a/src/lib/ranges/range_types/classic_range.cc
+++ b/src/lib/ranges/range_types/classic_range.cc
@@ -5,60 +5,60 @@
 namespace MultiArrayTools
 {
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
     
-    SingleRangeFactory<size_t,SpaceType::NONE>::SingleRangeFactory(size_t size)
+    GenSingleRangeFactory<size_t,SpaceType::NONE,-1>::GenSingleRangeFactory(size_t size)
     {
 	// Quasi Singleton
 	if(not mProd){
-	    mProd = std::shared_ptr<oType>( new SingleRange<size_t,SpaceType::NONE>(size) );
+	    mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::NONE,-1>(size) );
 	    setSelf();
 	}
     }
 
-    std::shared_ptr<RangeBase> SingleRangeFactory<size_t,SpaceType::NONE>::create()
+    std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::NONE,-1>::create()
     {
 	return mProd;
     }
     
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
 
-    SingleRange<size_t,SpaceType::NONE>::SingleRange(size_t size) : mSize(size) {}
+    GenSingleRange<size_t,SpaceType::NONE,-1>::GenSingleRange(size_t size) : mSize(size) {}
     
-    size_t SingleRange<size_t,SpaceType::NONE>::get(size_t pos) const
+    size_t GenSingleRange<size_t,SpaceType::NONE,-1>::get(size_t pos) const
     {
 	return pos;
     }
     
-    size_t SingleRange<size_t,SpaceType::NONE>::getMeta(size_t metaPos) const
+    size_t GenSingleRange<size_t,SpaceType::NONE,-1>::getMeta(size_t metaPos) const
     {
 	return metaPos;
     }
     
-    size_t SingleRange<size_t,SpaceType::NONE>::size() const
+    size_t GenSingleRange<size_t,SpaceType::NONE,-1>::size() const
     {
 	return mSize;
     }
     
-    size_t SingleRange<size_t,SpaceType::NONE>::dim() const
+    size_t GenSingleRange<size_t,SpaceType::NONE,-1>::dim() const
     {
 	return 1;
     }
 
-    SpaceType SingleRange<size_t,SpaceType::NONE>::spaceType() const
+    SpaceType GenSingleRange<size_t,SpaceType::NONE,-1>::spaceType() const
     {
 	return SpaceType::NONE;
     }
     
-    std::string SingleRange<size_t,SpaceType::NONE>::stringMeta(size_t pos) const
+    std::string GenSingleRange<size_t,SpaceType::NONE,-1>::stringMeta(size_t pos) const
     {
 	return std::to_string(get(pos));
     }
 
-    std::vector<char> SingleRange<size_t,SpaceType::NONE>::data() const
+    std::vector<char> GenSingleRange<size_t,SpaceType::NONE,-1>::data() const
     {
 	DataHeader h = dataHeader();
 	std::vector<char> out;
@@ -70,7 +70,7 @@ namespace MultiArrayTools
 	return out;
     }
 
-    DataHeader SingleRange<size_t,SpaceType::NONE>::dataHeader() const
+    DataHeader GenSingleRange<size_t,SpaceType::NONE,-1>::dataHeader() const
     {
 	DataHeader h;
 	h.spaceType = static_cast<int>( SpaceType::NONE );
@@ -80,17 +80,17 @@ namespace MultiArrayTools
     }
 
     
-    typename SingleRange<size_t,SpaceType::NONE>::IndexType SingleRange<size_t,SpaceType::NONE>::begin() const
+    typename GenSingleRange<size_t,SpaceType::NONE,-1>::IndexType GenSingleRange<size_t,SpaceType::NONE,-1>::begin() const
     {
-	SingleIndex<size_t,SpaceType::NONE> i( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::NONE> >
+	GenSingleIndex<size_t,SpaceType::NONE,-1> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NONE,-1> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = 0;
 	return i;
     }
     
-    typename SingleRange<size_t,SpaceType::NONE>::IndexType SingleRange<size_t,SpaceType::NONE>::end() const
+    typename GenSingleRange<size_t,SpaceType::NONE,-1>::IndexType GenSingleRange<size_t,SpaceType::NONE,-1>::end() const
     {
-	SingleIndex<size_t,SpaceType::NONE> i( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::NONE> >
+	GenSingleIndex<size_t,SpaceType::NONE,-1> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NONE,-1> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = size();
 	return i;
diff --git a/src/lib/ranges/range_types/null_range.cc b/src/lib/ranges/range_types/null_range.cc
index d42ebb5..46ac26b 100644
--- a/src/lib/ranges/range_types/null_range.cc
+++ b/src/lib/ranges/range_types/null_range.cc
@@ -10,11 +10,11 @@ namespace MultiArrayTools
     }
 	
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
 
-    std::shared_ptr<SingleRange<size_t,SpaceType::NUL>>
-    SingleRangeFactory<size_t,SpaceType::NUL>::mRInstance = nullptr;
+    std::shared_ptr<GenSingleRange<size_t,SpaceType::NUL,0>>
+    GenSingleRangeFactory<size_t,SpaceType::NUL,0>::mRInstance = nullptr;
     
     std::shared_ptr<NullRange> nullr()
     {
@@ -28,12 +28,12 @@ namespace MultiArrayTools
 	return std::make_shared<NullIndex>(nullr());
     }
 
-    SingleRangeFactory<size_t,SpaceType::NUL>::SingleRangeFactory()
+    GenSingleRangeFactory<size_t,SpaceType::NUL,0>::GenSingleRangeFactory()
     {
 	// Singleton
 	if(not mRInstance){
 	    if(not mProd){
-		mProd = std::shared_ptr<oType>( new SingleRange<size_t,SpaceType::NUL>() );
+		mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::NUL,0>() );
 		setSelf();
 	    }
 	    mRInstance = std::dynamic_pointer_cast<NullRange>( mProd );
@@ -42,46 +42,46 @@ namespace MultiArrayTools
 	}
     }
 
-    std::shared_ptr<RangeBase> SingleRangeFactory<size_t,SpaceType::NUL>::create()
+    std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::NUL,0>::create()
     {
 	return mProd;
     }
     
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
     
-    size_t SingleRange<size_t,SpaceType::NUL>::get(size_t pos) const
+    size_t GenSingleRange<size_t,SpaceType::NUL,0>::get(size_t pos) const
     {
 	return 0;
     }
     
-    size_t SingleRange<size_t,SpaceType::NUL>::getMeta(size_t metapos) const
+    size_t GenSingleRange<size_t,SpaceType::NUL,0>::getMeta(size_t metapos) const
     {
 	return 0;
     }
     
-    size_t SingleRange<size_t,SpaceType::NUL>::size() const
+    size_t GenSingleRange<size_t,SpaceType::NUL,0>::size() const
     {
 	return 1;
     }
     
-    size_t SingleRange<size_t,SpaceType::NUL>::dim() const
+    size_t GenSingleRange<size_t,SpaceType::NUL,0>::dim() const
     {
 	return 1;
     }
 
-    SpaceType SingleRange<size_t,SpaceType::NUL>::spaceType() const
+    SpaceType GenSingleRange<size_t,SpaceType::NUL,0>::spaceType() const
     {
 	return SpaceType::NUL;
     }
     
-    std::string SingleRange<size_t,SpaceType::NUL>::stringMeta(size_t pos) const
+    std::string GenSingleRange<size_t,SpaceType::NUL,0>::stringMeta(size_t pos) const
     {
 	return std::to_string(get(pos));
     }
 
-    std::vector<char> SingleRange<size_t,SpaceType::NUL>::data() const
+    std::vector<char> GenSingleRange<size_t,SpaceType::NUL,0>::data() const
     {
 	DataHeader h = dataHeader(); 
 	std::vector<char> out;
@@ -91,7 +91,7 @@ namespace MultiArrayTools
 	return out;
     }
 
-    DataHeader SingleRange<size_t,SpaceType::NUL>::dataHeader() const
+    DataHeader GenSingleRange<size_t,SpaceType::NUL,0>::dataHeader() const
     {
 	DataHeader h;
 	h.spaceType = static_cast<int>( SpaceType::NUL );
@@ -100,17 +100,17 @@ namespace MultiArrayTools
         return h;
     }
    
-    typename SingleRange<size_t,SpaceType::NUL>::IndexType SingleRange<size_t,SpaceType::NUL>::begin() const
+    typename GenSingleRange<size_t,SpaceType::NUL,0>::IndexType GenSingleRange<size_t,SpaceType::NUL,0>::begin() const
     {
-	SingleIndex<size_t,SpaceType::NUL> i( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::NUL> >
+	GenSingleIndex<size_t,SpaceType::NUL,0> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = 0;
 	return i;
     }
     
-    typename SingleRange<size_t,SpaceType::NUL>::IndexType SingleRange<size_t,SpaceType::NUL>::end() const
+    typename GenSingleRange<size_t,SpaceType::NUL,0>::IndexType GenSingleRange<size_t,SpaceType::NUL,0>::end() const
     {
-	SingleIndex<size_t,SpaceType::NUL> i( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::NUL> >
+	GenSingleIndex<size_t,SpaceType::NUL,0> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = size();
 	return i;
@@ -118,12 +118,12 @@ namespace MultiArrayTools
 
     // put this in the interface class !!!
     /*
-    std::shared_ptr<VIWB> SingleRange<size_t,SpaceType::NUL>::index() const
+    std::shared_ptr<VIWB> GenSingleRange<size_t,SpaceType::NUL,0>::index() const
     {
 	typedef IndexWrapper<IndexType> IW;
 	return std::make_shared<IW>
             ( std::make_shared<IndexType>
-	      ( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::NUL> >
+	      ( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::NUL,0> >
 		( std::shared_ptr<RangeBase>( RB::mThis ) ) ) );
     }
     */
diff --git a/src/lib/ranges/range_types/space_range.cc b/src/lib/ranges/range_types/space_range.cc
index e4ca7f3..ae4758e 100644
--- a/src/lib/ranges/range_types/space_range.cc
+++ b/src/lib/ranges/range_types/space_range.cc
@@ -11,60 +11,60 @@ namespace MultiArrayTools
     }
     
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
     
-    SingleRangeFactory<int,SpaceType::PSPACE>::SingleRangeFactory(size_t size)
+    GenSingleRangeFactory<int,SpaceType::PSPACE,-1>::GenSingleRangeFactory(size_t size)
     {
 	// Quasi Singleton
 	if(not mProd){
-	    mProd = std::shared_ptr<oType>( new SingleRange<int,SpaceType::PSPACE>(size) );
+	    mProd = std::shared_ptr<oType>( new GenSingleRange<int,SpaceType::PSPACE,-1>(size) );
 	    setSelf();
 	}
     }
 
-    std::shared_ptr<RangeBase> SingleRangeFactory<int,SpaceType::PSPACE>::create()
+    std::shared_ptr<RangeBase> GenSingleRangeFactory<int,SpaceType::PSPACE,-1>::create()
     {
 	return mProd;
     }
     
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
 
-    SingleRange<int,SpaceType::PSPACE>::SingleRange(size_t size) : mSize(size) { }
+    GenSingleRange<int,SpaceType::PSPACE,-1>::GenSingleRange(size_t size) : mSize(size) { }
     
-    int SingleRange<int,SpaceType::PSPACE>::get(size_t pos) const
+    int GenSingleRange<int,SpaceType::PSPACE,-1>::get(size_t pos) const
     {
 	return pos > mSize / 2 ? pos - mSize : pos;
     }
     
-    size_t SingleRange<int,SpaceType::PSPACE>::getMeta(int metaPos) const
+    size_t GenSingleRange<int,SpaceType::PSPACE,-1>::getMeta(int metaPos) const
     {
 	return metaPos < 0 ? metaPos + mSize : metaPos;
     }
     
-    size_t SingleRange<int,SpaceType::PSPACE>::size() const
+    size_t GenSingleRange<int,SpaceType::PSPACE,-1>::size() const
     {
 	return mSize;
     }
     
-    size_t SingleRange<int,SpaceType::PSPACE>::dim() const
+    size_t GenSingleRange<int,SpaceType::PSPACE,-1>::dim() const
     {
 	return 1;
     }
 
-    SpaceType SingleRange<int,SpaceType::PSPACE>::spaceType() const
+    SpaceType GenSingleRange<int,SpaceType::PSPACE,-1>::spaceType() const
     {
 	return SpaceType::PSPACE;
     }
     
-    std::string SingleRange<int,SpaceType::PSPACE>::stringMeta(size_t pos) const
+    std::string GenSingleRange<int,SpaceType::PSPACE,-1>::stringMeta(size_t pos) const
     {
 	return std::to_string(get(pos));
     }
 
-    std::vector<char> SingleRange<int,SpaceType::PSPACE>::data() const
+    std::vector<char> GenSingleRange<int,SpaceType::PSPACE,-1>::data() const
     {
 	DataHeader h = dataHeader();
 	std::vector<char> out;
@@ -76,7 +76,7 @@ namespace MultiArrayTools
 	return out;
     }
 
-    DataHeader SingleRange<int,SpaceType::PSPACE>::dataHeader() const
+    DataHeader GenSingleRange<int,SpaceType::PSPACE,-1>::dataHeader() const
     {
 	DataHeader h;
 	h.spaceType = static_cast<int>( SpaceType::PSPACE );
@@ -85,17 +85,17 @@ namespace MultiArrayTools
         return h;
     }
     
-    typename SingleRange<int,SpaceType::PSPACE>::IndexType SingleRange<int,SpaceType::PSPACE>::begin() const
+    typename GenSingleRange<int,SpaceType::PSPACE,-1>::IndexType GenSingleRange<int,SpaceType::PSPACE,-1>::begin() const
     {
-	SingleIndex<int,SpaceType::PSPACE> i( std::dynamic_pointer_cast<SingleRange<int,SpaceType::PSPACE> >
+	GenSingleIndex<int,SpaceType::PSPACE,-1> i( std::dynamic_pointer_cast<GenSingleRange<int,SpaceType::PSPACE,-1> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = 0;
 	return i;
     }
     
-    typename SingleRange<int,SpaceType::PSPACE>::IndexType SingleRange<int,SpaceType::PSPACE>::end() const
+    typename GenSingleRange<int,SpaceType::PSPACE,-1>::IndexType GenSingleRange<int,SpaceType::PSPACE,-1>::end() const
     {
-	SingleIndex<int,SpaceType::PSPACE> i( std::dynamic_pointer_cast<SingleRange<int,SpaceType::PSPACE> >
+	GenSingleIndex<int,SpaceType::PSPACE,-1> i( std::dynamic_pointer_cast<GenSingleRange<int,SpaceType::PSPACE,-1> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = size();
 	return i;
diff --git a/src/lib/ranges/range_types/spin_range.cc b/src/lib/ranges/range_types/spin_range.cc
index b391481..8ba73f4 100644
--- a/src/lib/ranges/range_types/spin_range.cc
+++ b/src/lib/ranges/range_types/spin_range.cc
@@ -10,58 +10,58 @@ namespace MultiArrayTools
     }
     
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
     
-    SingleRangeFactory<size_t,SpaceType::SPIN>::SingleRangeFactory()
+    GenSingleRangeFactory<size_t,SpaceType::SPIN,4>::GenSingleRangeFactory()
     {
 	// Quasi Singleton
 	if(not mProd){
-	    mProd = std::shared_ptr<oType>( new SingleRange<size_t,SpaceType::SPIN>() );
+	    mProd = std::shared_ptr<oType>( new GenSingleRange<size_t,SpaceType::SPIN,4>() );
 	    setSelf();
 	}
     }
 
-    std::shared_ptr<RangeBase> SingleRangeFactory<size_t,SpaceType::SPIN>::create()
+    std::shared_ptr<RangeBase> GenSingleRangeFactory<size_t,SpaceType::SPIN,4>::create()
     {
 	return mProd;
     }
     
     /********************
-     *   SingleRange    *
+     *   GenSingleRange    *
      ********************/
     
-    size_t SingleRange<size_t,SpaceType::SPIN>::get(size_t pos) const
+    size_t GenSingleRange<size_t,SpaceType::SPIN,4>::get(size_t pos) const
     {
 	return pos;
     }
     
-    size_t SingleRange<size_t,SpaceType::SPIN>::getMeta(size_t metaPos) const
+    size_t GenSingleRange<size_t,SpaceType::SPIN,4>::getMeta(size_t metaPos) const
     {
 	return metaPos;
     }
     
-    size_t SingleRange<size_t,SpaceType::SPIN>::size() const
+    size_t GenSingleRange<size_t,SpaceType::SPIN,4>::size() const
     {
 	return mSpinNum;
     }
     
-    size_t SingleRange<size_t,SpaceType::SPIN>::dim() const
+    size_t GenSingleRange<size_t,SpaceType::SPIN,4>::dim() const
     {
 	return 1;
     }
 
-    SpaceType SingleRange<size_t,SpaceType::SPIN>::spaceType() const
+    SpaceType GenSingleRange<size_t,SpaceType::SPIN,4>::spaceType() const
     {
 	return SpaceType::SPIN;
     }
     
-    std::string SingleRange<size_t,SpaceType::SPIN>::stringMeta(size_t pos) const
+    std::string GenSingleRange<size_t,SpaceType::SPIN,4>::stringMeta(size_t pos) const
     {
 	return std::to_string(get(pos));
     }
 
-    std::vector<char> SingleRange<size_t,SpaceType::SPIN>::data() const
+    std::vector<char> GenSingleRange<size_t,SpaceType::SPIN,4>::data() const
     {
 	DataHeader h = dataHeader();
 	std::vector<char> out;
@@ -71,7 +71,7 @@ namespace MultiArrayTools
 	return out;
     }
     
-    DataHeader SingleRange<size_t,SpaceType::SPIN>::dataHeader() const
+    DataHeader GenSingleRange<size_t,SpaceType::SPIN,4>::dataHeader() const
     {
 	DataHeader h;
 	h.spaceType = static_cast<int>( SpaceType::SPIN );
@@ -80,17 +80,17 @@ namespace MultiArrayTools
         return h;
     }    
     
-    typename SingleRange<size_t,SpaceType::SPIN>::IndexType SingleRange<size_t,SpaceType::SPIN>::begin() const
+    typename GenSingleRange<size_t,SpaceType::SPIN,4>::IndexType GenSingleRange<size_t,SpaceType::SPIN,4>::begin() const
     {
-	SingleIndex<size_t,SpaceType::SPIN> i( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::SPIN> >
+	GenSingleIndex<size_t,SpaceType::SPIN,4> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::SPIN,4> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = 0;
 	return i;
     }
     
-    typename SingleRange<size_t,SpaceType::SPIN>::IndexType SingleRange<size_t,SpaceType::SPIN>::end() const
+    typename GenSingleRange<size_t,SpaceType::SPIN,4>::IndexType GenSingleRange<size_t,SpaceType::SPIN,4>::end() const
     {
-	SingleIndex<size_t,SpaceType::SPIN> i( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::SPIN> >
+	GenSingleIndex<size_t,SpaceType::SPIN,4> i( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::SPIN,4> >
 			       ( std::shared_ptr<RangeBase>( RB::mThis ) ) );
 	i = size();
 	return i;
@@ -98,12 +98,12 @@ namespace MultiArrayTools
 
     // put this in the interface class !!!
     /*
-    std::shared_ptr<VIWB> SingleRange<size_t,SpaceType::SPIN>::index() const
+    std::shared_ptr<VIWB> GenSingleRange<size_t,SpaceType::SPIN,4>::index() const
     {
 	typedef IndexWrapper<IndexType> IW;
 	return std::make_shared<IW>
             ( std::make_shared<IndexType>
-	      ( std::dynamic_pointer_cast<SingleRange<size_t,SpaceType::SPIN> >
+	      ( std::dynamic_pointer_cast<GenSingleRange<size_t,SpaceType::SPIN,4> >
 		( std::shared_ptr<RangeBase>( RB::mThis ) ) ) );
     }
     */
diff --git a/src/tests/op_perf_test.cc b/src/tests/op_perf_test.cc
index 4c623ec..62accee 100644
--- a/src/tests/op_perf_test.cc
+++ b/src/tests/op_perf_test.cc
@@ -134,13 +134,14 @@ namespace {
 	typedef MultiRangeFactory<SR,SR,SR,SR,SR,SR,SR,SR> SR8F;
 	typedef SR8F::oType SR8;
 
-        static const size_t os = 3000;
-	static const size_t s = 65536*os;
-	
+        static const size_t os = 30;
+        static const size_t is = 65536;
+        static const size_t s = is*os;
+        
 	OpTest_Spin()
 	{
-	    data.resize(s);
-	    for(size_t i = 0; i != s; ++i){
+	    data.resize(is);
+	    for(size_t i = 0; i != is; ++i){
 		double arg = static_cast<double>( i - s ) - 0.1; 
 		data[i] = sin(arg);
 		//VCHECK(data[i]);
@@ -162,7 +163,7 @@ namespace {
 
     void OpTest_Spin::contract()
     {
-	MultiArray<double,CR,SR,SR,SR,SR,SR,SR,SR,SR> ma( cr, sr, sr, sr, sr, sr, sr, sr, sr, data);
+	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 );
 
         auto ii = MAT::getIndex<CR>(cr);
@@ -177,7 +178,8 @@ namespace {
 
 	std::clock_t begin = std::clock();
 	//for(size_t i = 0; i != os; ++i){
-        res1(ii ,delta, deltap).par() += ma(ii, delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
+        //res1(ii ,delta, deltap).par() += ma(ii, delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
+        res1(ii ,delta, deltap) += ma(delta, alpha, alpha, beta, beta, gamma, gamma, deltap).c(mix);
             //}
 	std::clock_t end = std::clock();
 	std::cout << "MultiArray time: " << static_cast<double>( end - begin ) / CLOCKS_PER_SEC
@@ -199,7 +201,7 @@ namespace {
                             for(size_t d = 0; d != 4; ++d){
                                 for(size_t p = 0; p != 4; ++p){
                                     const size_t tidx = i*4*4 + d*4 + p;
-                                    const size_t sidx = i*65536 + d*4*4*4*4*4*4*4 + a*5*4*4*4*4*4 + b*5*4*4*4 + c*5*4 + p;
+                                    const size_t sidx = /*i*65536 +*/ d*4*4*4*4*4*4*4 + a*5*4*4*4*4*4 + b*5*4*4*4 + c*5*4 + p;
                                     vres[tidx] += data[sidx];
                                 }
                             }