split cxz_operation: move Access and Expression classes to extra files

src/include/access.cc.h

@@ -0,0 +1,41 @@
+
+#include "access.h"
+
+namespace CNORXZ
+{
+    namespace
+    {
+	using namespace CNORXZInternal;
+    }
+
+    /************************
+     *   AccessTemplate     *
+     ************************/
+
+    template <class AccessClass>
+    auto AccessTemplate<AccessClass>::get(size_t pos)
+    {
+        return THIS().get(pos);
+    }
+
+    template <class AccessClass>
+    auto AccessTemplate<AccessClass>::get(size_t pos) const
+    {
+        return THIS().get(pos);
+    }
+
+    template <class AccessClass>
+    auto AccessTemplate<AccessClass>::oget(size_t pos) const
+    {
+	return THIS().oget(pos);
+    }
+
+    template <class AccessClass>
+    template <class F, typename Op, class ExtType>
+    void AccessTemplate<AccessClass>::exec(size_t pos, const Op& op, ExtType e) const
+    {
+        return THIS().template exec<F>(pos,op,e);
+    }
+
+
+} // namespace CNORXZ

src/include/access.h

@@ -0,0 +1,171 @@
+
+#ifndef __cxz_access_h__
+#define __cxz_access_h__
+
+namespace CNORXZ
+{
+    namespace
+    {
+	using namespace CNORXZInternal;
+    }
+
+    
+    template <class T>
+    struct VType
+    {
+	typedef T type;
+	static constexpr size_t MULT = sizeof(type)/sizeof(T);
+    };
+
+    template <>
+    struct VType<double>
+    {
+	typedef v256 type;
+	static constexpr size_t MULT = sizeof(type)/sizeof(double);
+    };
+
+    template <template <typename...> class F,typename... Ts>
+    inline auto mkVFuncPtr(const std::shared_ptr<F<Ts...>>& f)
+    {
+	return std::shared_ptr<F<typename VType<Ts>::type...>>();
+	// empty, implement corresponding constructors...!!!
+    }
+
+    template <template <typename...> class F,typename... Ts>
+    inline auto mkVFunc(const F<Ts...>& f)
+    {
+	return F<typename VType<Ts>::type...>();
+	// empty, implement corresponding constructors...!!!
+    }
+
+    
+    template <class F>
+    using VFunc = decltype(mkVFunc(std::declval<F>()));
+    
+    //template <class F>
+    //using VFunc = F;
+    
+    template <typename T, class F, class... Indices>
+    class OpAccess
+    {
+    private:
+	std::tuple<std::shared_ptr<Indices>...> mInds;
+	
+    public:
+	static constexpr bool ISSTATIC = false;
+	
+	template <typename Op, class ExtType>
+	inline void operator()(T*& t, size_t pos, const Op& op, ExtType e)
+	{
+	    F::selfApply(t[pos](mInds), op.get(e)); // s.th. like that
+	    // TODO for classes related to the r.h.s.:
+	    // forward get(e) to elements returned by get(e) until basic types are reached
+	    // (also same for rootSteps etc...) !!!!
+	    // introduce traits !!!!
+	    // !!!!
+	}
+    };
+
+    // static polymorphism
+    template <class AccessClass>
+    class AccessTemplate
+    {
+    public:
+        typedef AccessClass AC;
+
+	AccessTemplate(const AccessTemplate& in) = default;
+	AccessTemplate(AccessTemplate&& in) = default;
+	AccessTemplate& operator=(const AccessTemplate& in) = default;
+	AccessTemplate& operator=(AccessTemplate&& in) = default;
+
+        AccessClass& THIS() { return static_cast<AccessClass&>(*this); }
+        const AccessClass& THIS() const { return static_cast<const AccessClass&>(*this); }
+
+        inline auto get(size_t pos);
+        inline auto get(size_t pos) const;
+        inline auto oget(size_t pos) const;
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const;
+
+    protected:
+	AccessTemplate() = default;
+    };
+
+    template <typename T>
+    class PointerAccess : public AccessTemplate<PointerAccess<T>>
+    {
+    public:
+	typedef T value_type;
+	typedef T in_type;
+
+	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
+	
+	friend class AccessTemplate<PointerAccess<T>>;
+    private:
+	PointerAccess() = default;
+	
+        T* mPtr = nullptr;
+        T* mOrigPtr = nullptr;
+        
+    public:
+        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
+	
+	PointerAccess(const PointerAccess& in) = default;
+	PointerAccess(PointerAccess&& in) = default;
+	PointerAccess& operator=(const PointerAccess& in) = default;
+	PointerAccess& operator=(PointerAccess&& in) = default;
+
+        T* get(size_t pos) { return mPtr+pos; }
+        T* get(size_t pos) const { return mPtr+pos; }
+        PointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
+        T* oget(size_t pos) const { return mOrigPtr+pos; }
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const
+        {
+	    F::selfApply(*get(pos),op.get(e));
+        }
+    };
+
+    template <typename T>
+    class VPointerAccess : public AccessTemplate<VPointerAccess<T>>
+    {
+    public:
+	typedef typename VType<T>::type value_type;
+	typedef T in_type;
+
+	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
+
+	friend class AccessTemplate<VPointerAccess<T>>;
+    private:
+	VPointerAccess() = default;
+	
+        T* mPtr = nullptr;
+        T* mOrigPtr = nullptr;
+        
+    public:
+        VPointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
+	
+	VPointerAccess(const VPointerAccess& in) = default;
+	VPointerAccess(VPointerAccess&& in) = default;
+	VPointerAccess& operator=(const VPointerAccess& in) = default;
+	VPointerAccess& operator=(VPointerAccess&& in) = default;
+
+        VType<T>* get(size_t pos) { return reinterpret_cast<VType<T>*>(mPtr+pos); }
+        VType<T>* get(size_t pos) const { return reinterpret_cast<VType<T>*>(mPtr+pos); }
+        VPointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
+        VType<T>* oget(size_t pos) const { return reinterpret_cast<VType<T>*>(mOrigPtr+pos); }
+
+	template <class F, typename Op, class ExtType>
+	inline void exec(size_t pos, const Op& op, ExtType e) const
+        {
+	    CHECK;
+	    F::selfApply(*get(pos),op.vget(e));
+        }
+    };
+
+    
+} // namespace CNORXZ
+
+#endif

src/include/cnorxz.cc.h

@@ -10,6 +10,8 @@
 #include "cxz_array.cc.h"
 #include "slice.cc.h"
 #include "dynamic_operation.cc.h"
+#include "access.cc.h"
+#include "op_expressions.cc.h"
 //#include "high_level_operation.cc.h"
 //#include "expressions.cc.h"
 

src/include/cxz_operation.cc.h

@@ -136,94 +136,9 @@ namespace CNORXZ
     }
     */
 
-    /************************
+    /******************
-     *   AccessTemplate     *
+     *      MOp       *
-     ************************/
+     ******************/
-
-    template <class AccessClass>
-    auto AccessTemplate<AccessClass>::get(size_t pos)
-    {
-        return THIS().get(pos);
-    }
-
-    template <class AccessClass>
-    auto AccessTemplate<AccessClass>::get(size_t pos) const
-    {
-        return THIS().get(pos);
-    }
-
-    template <class AccessClass>
-    auto AccessTemplate<AccessClass>::oget(size_t pos) const
-    {
-	return THIS().oget(pos);
-    }
-
-    template <class AccessClass>
-    template <class F, typename Op, class ExtType>
-    void AccessTemplate<AccessClass>::exec(size_t pos, const Op& op, ExtType e) const
-    {
-        return THIS().template exec<F>(pos,op,e);
-    }
-
-    /************************
-     *   AssignmentExpr     *
-     ************************/
-
-    template <OpIndexAff OIA, class ExtType>
-    inline size_t opIndexResolve(size_t start, ExtType last)
-    {
-        if constexpr(OIA == OpIndexAff::EXTERN){
-            return last.val();
-        }
-        if constexpr(OIA == OpIndexAff::TARGET){
-            return start;
-        }
-        return 0;
-    }
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
-        mTar(tar), mSec(sec), mDataAcc(static_cast<const AT&>(dataAcc)) {}
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t start)
-    {
-        ExtType last = rootSteps();
-	last.zero();
-	// TODO: ask MA container for data (ptr)!!!
-	mDataAcc.template exec<Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
-    }
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
-    {
-	mDataAcc.template exec<Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
-    }
-    
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    typename AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::ExtType
-    AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
-    {
-	return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
-    }
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
-    {
-        (*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
-    }
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
-    {
-        return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
-    }
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
-    inline DExt AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::dExtension() const
-    {
-        return nullptr; //???!!!
-    }
 
     template <typename T, class... Ops>
     MOp<T,Ops...>::MOp(const Ops&... exprs) : mOps(exprs...)

src/include/cxz_operation.h

@@ -18,6 +18,8 @@
 #include "arith.h"
 #include "xfor/xfor.h"
 #include "type_operations.h"
+#include "op_expressions.h"
+#include "access.h"
 
 #include "statics/static_for.h"
 
@@ -100,204 +102,6 @@ namespace CNORXZ
         }
     };
 
-    enum class OpIndexAff {
-                           EXTERN = 0,
-                           TARGET = 1
-    };
-
-    template <class T>
-    struct VType
-    {
-	typedef T type;
-	static constexpr size_t MULT = sizeof(type)/sizeof(T);
-    };
-
-    template <>
-    struct VType<double>
-    {
-	typedef v256 type;
-	static constexpr size_t MULT = sizeof(type)/sizeof(double);
-    };
-
-    template <template <typename...> class F,typename... Ts>
-    inline auto mkVFuncPtr(const std::shared_ptr<F<Ts...>>& f)
-    {
-	return std::shared_ptr<F<typename VType<Ts>::type...>>();
-	// empty, implement corresponding constructors...!!!
-    }
-
-    template <template <typename...> class F,typename... Ts>
-    inline auto mkVFunc(const F<Ts...>& f)
-    {
-	return F<typename VType<Ts>::type...>();
-	// empty, implement corresponding constructors...!!!
-    }
-
-    
-    template <class F>
-    using VFunc = decltype(mkVFunc(std::declval<F>()));
-    
-    //template <class F>
-    //using VFunc = F;
-    
-    template <typename T, class F, class... Indices>
-    class OpAccess
-    {
-    private:
-	std::tuple<std::shared_ptr<Indices>...> mInds;
-	
-    public:
-	static constexpr bool ISSTATIC = false;
-	
-	template <typename Op, class ExtType>
-	inline void operator()(T*& t, size_t pos, const Op& op, ExtType e)
-	{
-	    F::selfApply(t[pos](mInds), op.get(e)); // s.th. like that
-	    // TODO for classes related to the r.h.s.:
-	    // forward get(e) to elements returned by get(e) until basic types are reached
-	    // (also same for rootSteps etc...) !!!!
-	    // introduce traits !!!!
-	    // !!!!
-	}
-    };
-
-    // static polymorphism
-    template <class AccessClass>
-    class AccessTemplate
-    {
-    public:
-        typedef AccessClass AC;
-
-	AccessTemplate(const AccessTemplate& in) = default;
-	AccessTemplate(AccessTemplate&& in) = default;
-	AccessTemplate& operator=(const AccessTemplate& in) = default;
-	AccessTemplate& operator=(AccessTemplate&& in) = default;
-
-        AccessClass& THIS() { return static_cast<AccessClass&>(*this); }
-        const AccessClass& THIS() const { return static_cast<const AccessClass&>(*this); }
-
-        inline auto get(size_t pos);
-        inline auto get(size_t pos) const;
-        inline auto oget(size_t pos) const;
-
-	template <class F, typename Op, class ExtType>
-	inline void exec(size_t pos, const Op& op, ExtType e) const;
-
-    protected:
-	AccessTemplate() = default;
-    };
-
-    template <typename T>
-    class PointerAccess : public AccessTemplate<PointerAccess<T>>
-    {
-    public:
-	typedef T value_type;
-	typedef T in_type;
-
-	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
-	
-	friend class AccessTemplate<PointerAccess<T>>;
-    private:
-	PointerAccess() = default;
-	
-        T* mPtr = nullptr;
-        T* mOrigPtr = nullptr;
-        
-    public:
-        PointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
-	
-	PointerAccess(const PointerAccess& in) = default;
-	PointerAccess(PointerAccess&& in) = default;
-	PointerAccess& operator=(const PointerAccess& in) = default;
-	PointerAccess& operator=(PointerAccess&& in) = default;
-
-        T* get(size_t pos) { return mPtr+pos; }
-        T* get(size_t pos) const { return mPtr+pos; }
-        PointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
-        T* oget(size_t pos) const { return mOrigPtr+pos; }
-
-	template <class F, typename Op, class ExtType>
-	inline void exec(size_t pos, const Op& op, ExtType e) const
-        {
-	    F::selfApply(*get(pos),op.get(e));
-        }
-    };
-
-    template <typename T>
-    class VPointerAccess : public AccessTemplate<VPointerAccess<T>>
-    {
-    public:
-	typedef typename VType<T>::type value_type;
-	typedef T in_type;
-
-	static constexpr size_t VSIZE = sizeof(value_type) / sizeof(in_type);
-
-	friend class AccessTemplate<VPointerAccess<T>>;
-    private:
-	VPointerAccess() = default;
-	
-        T* mPtr = nullptr;
-        T* mOrigPtr = nullptr;
-        
-    public:
-        VPointerAccess(T* ptr, T* origPtr) : mPtr(ptr), mOrigPtr(origPtr) {}
-	
-	VPointerAccess(const VPointerAccess& in) = default;
-	VPointerAccess(VPointerAccess&& in) = default;
-	VPointerAccess& operator=(const VPointerAccess& in) = default;
-	VPointerAccess& operator=(VPointerAccess&& in) = default;
-
-        VType<T>* get(size_t pos) { return reinterpret_cast<VType<T>*>(mPtr+pos); }
-        VType<T>* get(size_t pos) const { return reinterpret_cast<VType<T>*>(mPtr+pos); }
-        VPointerAccess<T>& set(size_t pos) { mPtr = mOrigPtr + pos; return *this; }
-        VType<T>* oget(size_t pos) const { return reinterpret_cast<VType<T>*>(mOrigPtr+pos); }
-
-	template <class F, typename Op, class ExtType>
-	inline void exec(size_t pos, const Op& op, ExtType e) const
-        {
-	    CHECK;
-	    F::selfApply(*get(pos),op.vget(e));
-        }
-    };
-
-
-    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
-    class AssignmentExpr : public ExpressionBase
-    {
-    private:
-        AssignmentExpr() = default;
-
-        Target mTar;
-        OpClass mSec;
-	AT mDataAcc;
-            
-    public:
-
-        static constexpr size_t LAYER = 0;
-        static constexpr size_t NHLAYER = 0;
-        static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
-        typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
-	    
-	AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec);
-        AssignmentExpr(const AssignmentExpr& in) = default;
-        AssignmentExpr(AssignmentExpr&& in) = default;
-        AssignmentExpr& operator=(const AssignmentExpr& in) = default;
-        AssignmentExpr& operator=(AssignmentExpr&& in) = default;
-
-	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
-	{
-	    return std::make_shared<AssignmentExpr<T,Func,AT,Target,OpClass,OIA>>(*this);
-	}
-	
-        inline void operator()(size_t start = 0); 
-        inline void operator()(size_t start, ExtType last);
-        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
-
-        inline void operator()(size_t mlast, DExt last) override final;
-
-        inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
-        inline DExt dExtension() const override final;
-    };
 
     template <class... Ops>
     struct OperationTuple

src/include/op_expressions.cc.h

@@ -0,0 +1,72 @@
+
+#include "op_expressions.h"
+
+namespace CNORXZ
+{
+    namespace
+    {
+	using namespace CNORXZInternal;
+    }
+
+    /************************
+     *   AssignmentExpr     *
+     ************************/
+
+    template <OpIndexAff OIA, class ExtType>
+    inline size_t opIndexResolve(size_t start, ExtType last)
+    {
+        if constexpr(OIA == OpIndexAff::EXTERN){
+            return last.val();
+        }
+        if constexpr(OIA == OpIndexAff::TARGET){
+            return start;
+        }
+        return 0;
+    }
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec) :
+        mTar(tar), mSec(sec), mDataAcc(static_cast<const AT&>(dataAcc)) {}
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t start)
+    {
+        ExtType last = rootSteps();
+	last.zero();
+	// TODO: ask MA container for data (ptr)!!!
+	mDataAcc.template exec<Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+    }
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t start, ExtType last)
+    {
+	mDataAcc.template exec<Func>(opIndexResolve<OIA>(start,last),mSec,last.next());
+    }
+    
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    typename AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::ExtType
+    AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::rootSteps(std::intptr_t iPtrNum) const
+    {
+	return mTar.rootSteps(iPtrNum).extend( mSec.rootSteps(iPtrNum) );
+    }
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline void AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::operator()(size_t mlast, DExt last)
+    {
+        (*this)(mlast, std::dynamic_pointer_cast<ExtT<ExtType>>(last)->ext());
+    }
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::dRootSteps(std::intptr_t iPtrNum) const
+    {
+        return std::make_shared<ExtT<ExtType>>(rootSteps(iPtrNum));
+    }
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA>
+    inline DExt AssignmentExpr<T,Func,AT,Target,OpClass,OIA>::dExtension() const
+    {
+        return nullptr; //???!!!
+    }
+
+    
+} // namespace CNORXZ

src/include/op_expressions.h

@@ -0,0 +1,60 @@
+
+#ifndef __cxz_op_expressions__
+#define __cxz_op_expressions__
+
+#include "xfor/xfor.h"
+#include "access.h"
+
+namespace CNORXZ
+{
+    namespace
+    {
+	using namespace CNORXZInternal;
+    }
+
+    enum class OpIndexAff {
+	EXTERN = 0,
+	TARGET = 1
+    };
+
+    template <typename T, class Func, class AT, class Target, class OpClass, OpIndexAff OIA=OpIndexAff::EXTERN>
+    class AssignmentExpr : public ExpressionBase
+    {
+    private:
+        AssignmentExpr() = default;
+
+        Target mTar;
+        OpClass mSec;
+	AT mDataAcc;
+            
+    public:
+
+        static constexpr size_t LAYER = 0;
+        static constexpr size_t NHLAYER = 0;
+        static constexpr size_t SIZE = Target::SIZE + OpClass::SIZE;
+        typedef decltype(mTar.rootSteps(0).extend( mSec.rootSteps(0) )) ExtType;
+	    
+	AssignmentExpr(const AccessTemplate<AT>& dataAcc, const Target& tar, const OpClass& sec);
+        AssignmentExpr(const AssignmentExpr& in) = default;
+        AssignmentExpr(AssignmentExpr&& in) = default;
+        AssignmentExpr& operator=(const AssignmentExpr& in) = default;
+        AssignmentExpr& operator=(AssignmentExpr&& in) = default;
+
+	virtual std::shared_ptr<ExpressionBase> deepCopy() const override final
+	{
+	    return std::make_shared<AssignmentExpr<T,Func,AT,Target,OpClass,OIA>>(*this);
+	}
+	
+        inline void operator()(size_t start = 0); 
+        inline void operator()(size_t start, ExtType last);
+        auto rootSteps(std::intptr_t iPtrNum = 0) const -> ExtType;
+
+        inline void operator()(size_t mlast, DExt last) override final;
+
+        inline DExt dRootSteps(std::intptr_t iPtrNum = 0) const override final;
+        inline DExt dExtension() const override final;
+    };
+
+} // namespace CNORXZ
+
+#endif