diff --git a/.development/test_new.cpp b/.development/test_new.cpp
index ef8bbea..516baf4 100644
--- a/.development/test_new.cpp
+++ b/.development/test_new.cpp
@@ -1,5 +1,19 @@
+/*
+g++ test_new.cpp -std=c++20 -g -Wall -Wpedantic -Wextra -Wconversion
+-Wconversion -Wunitialized -Wshadow -Wmissing-declarations
+-Wimplicit-fallthrough
+-Wduplicated-cond
+-Wsign-compare
+-Wformat
+-Wnull-dereference
+-Wdeprecated
+-Wstrict-aliasing
+*/
 #define STANDALONE_ETR
 #include "../inst/include/etr_bits/Core.hpp"
+#include "../inst/include/etr_bits/BufferVector.hpp"
+#include "../inst/include/etr_bits/BinaryCalculations.hpp"
+#include "../inst/include/etr_bits/UnaryCalculations.hpp"
 using namespace etr;
 
 int main() {
@@ -11,5 +25,14 @@ int main() {
   Borrow<double> b(ptr, 5);
   std::cout << b << std::endl;
 
+  Vec<double> vec(SI{10});
+  std::cout << vec.size() << std::endl;
+  for (auto& i: vec) i = 3.14;
+  vec = -(vec + vec);
+  std::cout << vec << std::endl;
+
+
+  vec[0] = 10;
+
   delete[] ptr;
 }
diff --git a/inst/include/etr_bits/BinaryCalculations.hpp b/inst/include/etr_bits/BinaryCalculations.hpp
index fc1fd95..e22e4e1 100644
--- a/inst/include/etr_bits/BinaryCalculations.hpp
+++ b/inst/include/etr_bits/BinaryCalculations.hpp
@@ -3,25 +3,14 @@
 
 #include "Core.hpp"
 
-// TODO: what is needed in order that for loops work with Operations
-/*
-RetType* p;
-auto begin() const {
-  return It<RetType>{p};
-}
-auto end() const {
-  return It<RetType>{p + this -> size()};
-}
-*/
-
 namespace etr {
 
-template <typename L, typename R, typename Trait, typename CTrait>
+template <typename L, typename R, typename BTrait>
 struct BinaryOperation {
-  using Type = DoubleTrait;
-  using TypeTrait = Trait;
-  using CaseTrait = BinaryTrait;
-  using RetType = typename CTrait::RetType;
+  using Trait = BTrait;
+  // TODO: the identification of RetType misses the fact that it is bool if 
+  // BTrait is part of the Comparison Traits
+  using RetType = std::common_type_t<typename L::RetType, typename R::RetType>;
   const L &l;
   const R &r;
   using typeTraitL = L;
@@ -39,12 +28,10 @@ struct BinaryOperation {
     } else {
       return l.im() || r.im();
     }
-    return false; // TODO: correct?
+    return false;
   }
   std::size_t nc() const {
     if constexpr (IsArithV<L>) {
-      // TODO: check whether one has to add here the test whether R and L are
-      // matrices. Same is true for nr
       return r.nc();
     } else if constexpr (IsArithV<R>) {
       return l.nc();
@@ -88,14 +75,14 @@ struct BinaryOperation {
   // TODO: are all of those constructors required?
   // Actually only   BinaryOperation(const L &l_, const R &r_) : l(l_), r(r_) {}
   // is used.
-  BinaryOperation(const BinaryOperation &other) : l(other.l), r(other.r) {}
-  BinaryOperation(const BinaryOperation &&other)
-      : l(std::move(other.l)), r(std::move(other.r)) {}
+  // BinaryOperation(const BinaryOperation &other) : l(other.l), r(other.r) {}
+  // BinaryOperation(const BinaryOperation &&other)
+  //     : l(std::move(other.l)), r(std::move(other.r)) {}
   BinaryOperation(const L &l_, const R &r_) : l(l_), r(r_) {}
-  template <typename LType, typename RType, typename TraitOther>
-  BinaryOperation(const BinaryOperation<LType, RType, TraitOther>
-                      &other) // TODO: needs move constructor
-      : l(other.l), r(other.r) {}
+  // template <typename LType, typename RType, typename TraitOther>
+  // BinaryOperation(const BinaryOperation<LType, RType, TraitOther>
+  //                     &other) // TODO: needs move constructor
+  //     : l(other.l), r(other.r) {}
 
   auto operator[](std::size_t i) const {
     constexpr bool isDoubleL = IsArithV<L>;
@@ -132,21 +119,6 @@ struct BinaryOperation {
     mp.setMatrix(mp_.ismatrix, mp_.rows, mp_.cols);
   }
 
-  template <typename AV> static std::size_t getSize(AV &av) {
-    using TyL = typename ReRef<typeTraitL>::type;
-    using TyR = typename ReRef<typeTraitR>::type;
-    return TyL::getSize(av) > TyR::getSize(av) ? TyL::getSize(av)
-                                               : TyR::getSize(av);
-  }
-  template <typename AV>
-  static RetType getVal(AV &av,
-                        std::size_t VecIdx) { // issue: how to handle scalar
-                                              // types? Or temporary types?
-    using TyL = typename ReRef<typeTraitL>::type;
-    using TyR = typename ReRef<typeTraitR>::type;
-    return f(TyL::template getVal<AV>(av, VecIdx % TyL::getSize(av)),
-             TyR::template getVal<AV>(av, VecIdx % TyR::getSize(av)));
-  }
 };
 
 template <typename L, typename R> auto operator+(const L &l, const R &r) {
diff --git a/inst/include/etr_bits/Core/BaseStore.hpp b/inst/include/etr_bits/Core/BaseStore.hpp
index 02e57e0..240c8b6 100644
--- a/inst/include/etr_bits/Core/BaseStore.hpp
+++ b/inst/include/etr_bits/Core/BaseStore.hpp
@@ -101,7 +101,7 @@ template <typename T, typename BaseTrait> struct BaseStore {
   };
 #endif
   BaseStore(std::size_t sz_)
-      : sz(sz_), capacity(static_cast<std::size_t>(sz_ * 1.15)) {
+      : sz(sz_), capacity(static_cast<std::size_t>(static_cast<double>(sz_)* 1.15)) {
     ass<"Size has to be larger than 0!">(sz_ > 0);
     p = new T[capacity];
     for (std::size_t i = 0; i < capacity; i++) {
@@ -111,7 +111,7 @@ template <typename T, typename BaseTrait> struct BaseStore {
   }
   BaseStore(int sz_)
       : sz(static_cast<std::size_t>(sz_)),
-        capacity(static_cast<std::size_t>(sz_ * 1.15)) {
+        capacity(static_cast<std::size_t>(static_cast<double>(sz_) * 1.15)) {
     ass<"Size has to be larger than 0!!">(sz_ > 0);
     p = new T[capacity];
     for (std::size_t i = 0; i < sz; i++)
@@ -140,7 +140,7 @@ template <typename T, typename BaseTrait> struct BaseStore {
   }
 
   template <typename TInp>
-    requires(IsArithV<ReRef<TInp>>)
+    requires(IsArithV<TInp>)
   void fill(TInp &&val) {
     if constexpr (IS<T, TInp>) {
       std::fill(p, p + sz, val);
@@ -150,7 +150,9 @@ template <typename T, typename BaseTrait> struct BaseStore {
     }
   }
 
-  template <typename TInp> void fill(TInp &&inp) {
+  template <typename TInp> 
+requires (!IsArithV<TInp>)
+  void fill(TInp &&inp) {
     ass<"cannot use fill with vectors of different lengths">(inp.size() == sz);
     using DataType =
         typename ExtractDataType<ReRef<TInp>>::RetType;
@@ -251,12 +253,12 @@ template <typename T, typename BaseTrait> struct BaseStore {
       p = nullptr;
     }
     sz = size;
-    capacity = static_cast<std::size_t>(1.15 * sz);
+    capacity = static_cast<std::size_t>(1.15 * static_cast<double>(sz));
     p = new T[capacity];
     allocated = true;
   }
   void resize(std::size_t newSize) {
-    ass<"Size has to be larger than 0!!!">(newSize >= 0);
+    ass<"Size has to be larger than 0!!!">(newSize > 0);
     if (!allocated) {
       init(newSize);
       fill(T());
@@ -265,7 +267,7 @@ template <typename T, typename BaseTrait> struct BaseStore {
       if (newSize > capacity) {
         ass<"try to delete nullptr">(p != nullptr);
         delete[] p;
-        capacity = static_cast<std::size_t>(newSize * 1.15);
+        capacity = static_cast<std::size_t>(static_cast<double>(newSize) * 1.15);
         p = new T[capacity];
         sz = newSize;
         allocated = true;
@@ -278,25 +280,26 @@ template <typename T, typename BaseTrait> struct BaseStore {
   }
 
   RetType operator[](std::size_t idx) const {
-    // TODO: can ass be faster?
     ass<"No memory was allocated">(allocated);
-    ass<"Error: out of boundaries --> value below 1">(idx >= 0);
-    ass<"Error: out of boundaries --> value beyond size of vector">(idx < sz);
+    // NOTE: negative idx leads to overflow and
+    // is than the max possible value of std::size_t
+    ass<"Error: out of boundaries">(idx < sz);
     return p[idx];
   }
 
-  // TODO: check with static_asssert that this is never called for const T
+  // TODO: update the assertions for all operator[]
   RetType &operator[](std::size_t idx) {
     ass<"No memory was allocated">(allocated);
-    ass<"Error: out of boundaries --> value below 1">(idx >= 0);
+    // NOTE: negative idx leads to overflow and
+    // is than the max possible value of std::size_t
     ass<"Error: out of boundaries --> value beyond size of vector">(idx < sz);
     return p[idx];
   }
 
   template <typename L2> void moveit(L2 &other) {
     T *temporary = other.p;
-    int tempSize = other.sz;
-    int tempCapacity = other.capacity;
+    std::size_t tempSize = other.sz;
+    std::size_t tempCapacity = other.capacity;
     other.p = this->p;
     other.sz = this->sz;
     other.capacity = this->capacity;
diff --git a/inst/include/etr_bits/Core/Borrow.hpp b/inst/include/etr_bits/Core/Borrow.hpp
index a8f0747..6534bef 100644
--- a/inst/include/etr_bits/Core/Borrow.hpp
+++ b/inst/include/etr_bits/Core/Borrow.hpp
@@ -58,16 +58,16 @@ template <typename T, typename BorrowTrait> struct Borrow {
   };
   Borrow(std::size_t r, std::size_t c) = delete;
   Borrow(std::size_t r, std::size_t c, const double value) = delete;
-  Borrow(T *p, std::size_t sz) {
-    this->p = p;
-    this->sz = sz;
+  Borrow(T *p_, std::size_t sz_) {
+    this->p = p_;
+    this->sz = sz_;
     capacity = sz;
     this->allocated = true;
   }
 
-  void init(T *p, std::size_t sz) {
-    this->p = p;
-    this->sz = sz;
+  void init(T *p_, std::size_t sz_) {
+    this->p = p_;
+    this->sz = sz_;
     capacity = sz;
     this->allocated = true;
   }
diff --git a/inst/include/etr_bits/Core/Concepts.hpp b/inst/include/etr_bits/Core/Concepts.hpp
index 44d4385..2307f19 100644
--- a/inst/include/etr_bits/Core/Concepts.hpp
+++ b/inst/include/etr_bits/Core/Concepts.hpp
@@ -15,12 +15,20 @@ concept isBID = requires {
   requires IS<T, bool> || IS<T, int> ||
                IS<T, double>;
 };
+
+// Test R class
+// ===================================================================
 template <typename T>
 concept IsSubset = requires {
     typename ReRef<T>::type::Trait;
     requires IS<typename ReRef<T>::type::Trait, SubsetTrait>;
 };
 template <typename T>
+concept IsSubsetClass = requires {
+    typename ReRef<T>::type::Trait;
+    requires IS<typename ReRef<T>::type::Trait, SubsetClassTrait>;
+};
+template <typename T>
 concept IsLBuffer = requires {
     typename ReRef<T>::type::Trait;
     requires IS<typename ReRef<T>::type::Trait, LBufferTrait>;
@@ -30,13 +38,21 @@ concept IsRBuffer = requires {
     typename ReRef<T>::type::Trait;
     requires IS<typename ReRef<T>::type::Trait, RBufferTrait>;
 };
+template <typename T>
+concept IsBorrow = requires {
+    typename ReRef<T>::type::Trait;
+    requires IS<typename ReRef<T>::type::Trait, BorrowTrait>;
+};
+template <typename T>
+concept IsBorrowSEXP = requires {
+    typename ReRef<T>::type::Trait;
+    requires IS<typename ReRef<T>::type::Trait, BorrowSEXPTrait>;
+};
 
 template <typename T>
 concept IsUnary = requires {
     typename ReRef<decltype(T{})>::type::Trait;
-    requires IS<
-        typename ReRef<decltype(T{})>::type::Trait,
-        SinusTrait> ||
+    requires IS<typename ReRef<decltype(T{})>::type::Trait, SinusTrait> ||
         IS<typename ReRef<decltype(T{})>::type::Trait, ASinusTrait> ||
         IS<typename ReRef<decltype(T{})>::type::Trait, SinusHTrait> ||
         IS<typename ReRef<decltype(T{})>::type::Trait, CosinusTrait> ||
@@ -52,22 +68,22 @@ concept IsUnary = requires {
 };
 template <typename T>
 concept IsBinary = requires {
-    typename ReRef<decltype(T{})>::type::Trait;
-    requires IS<
-        typename ReRef<decltype(T{})>::type::Trait,
-        PlusTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, MinusTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, TimesTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, DivideTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, PowTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, EqualTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, SmallerTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, SmallerEqualTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, LargerTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, LargerEqualTrait> ||
-        IS<typename ReRef<decltype(T{})>::type::Trait, UnEqualTrait>;
+    typename ReRef<T>::type::Trait;
+    requires IS<typename ReRef<T>::type::Trait, PlusTrait> ||
+        IS<typename ReRef<T>::type::Trait, MinusTrait> ||
+        IS<typename ReRef<T>::type::Trait, TimesTrait> ||
+        IS<typename ReRef<T>::type::Trait, DivideTrait> ||
+        IS<typename ReRef<T>::type::Trait, PowTrait> ||
+        IS<typename ReRef<T>::type::Trait, EqualTrait> ||
+        IS<typename ReRef<T>::type::Trait, SmallerTrait> ||
+        IS<typename ReRef<T>::type::Trait, SmallerEqualTrait> ||
+        IS<typename ReRef<T>::type::Trait, LargerTrait> ||
+        IS<typename ReRef<T>::type::Trait, LargerEqualTrait> ||
+        IS<typename ReRef<T>::type::Trait, UnEqualTrait>;
 };
 
+// Test Vec class
+// ===================================================================
 template <typename T>
 concept IsLBufferVec = requires(T t) {
   typename T::DType;
@@ -84,6 +100,9 @@ concept IsSubsetVec = requires(T t) {
   requires IsSubset<typename T::DType>;
 };
 
+// Test Input class
+// ===================================================================
+// Vector
 template <typename T>
 struct is_vec: std::false_type {};
 
@@ -95,13 +114,29 @@ inline constexpr bool is_vec_v = is_vec <T>::value;
 template <typename T>
 concept IsVec = is_vec_v<T>;
 
-
 template <typename T>
 concept IsRVec = requires(T t) {
   typename T::DType;
   requires IsVec<T> && IsRBuffer<typename T::DType>;
 };
 
+
+// Binary
+template <typename T>
+struct is_binary_operation : std::false_type {};
+
+template <typename L2, typename R2, typename OperationTrait>
+struct is_binary_operation<BinaryOperation<L2, R2, OperationTrait>>
+    : std::bool_constant<IsBinary<OperationTrait>> {};
+
+template <typename T>
+inline constexpr bool is_binary_operation_v = is_binary_operation<T>::value;
+
+template <typename T>
+concept IsBinaryOperation = is_binary_operation_v<T>;
+
+
+
 } // namespace etr
 
 #endif
diff --git a/inst/include/etr_bits/Core/Types.hpp b/inst/include/etr_bits/Core/Types.hpp
index 11434de..b452e13 100644
--- a/inst/include/etr_bits/Core/Types.hpp
+++ b/inst/include/etr_bits/Core/Types.hpp
@@ -1,3 +1,9 @@
+// TODO: add the iterator to each class: Buffer, Subset, Binary, Unary, Borrow, BorrowSEXP
+// Directly use the iterator methods begin, end etc. in Vec
+// Replace BaseStore with Buffer.
+// Each class has to possess RetType and Trait
+
+
 #ifndef TYPES_ETR_H
 #define TYPES_ETR_H
 
@@ -13,13 +19,14 @@ template <typename T = double, typename BorrowSEXPTrait = BorrowSEXPTrait>
 struct BorrowSEXP;
 template <typename T, typename BorrowTrait = BorrowTrait> struct Borrow;
 template <typename T, typename SubsetTrait = SubsetTrait> struct Subset;
+template <typename L, typename R, typename Trait> struct SubsetClass;
 template <typename T, typename BufferTrait = LBufferTrait>
 struct Buffer;
 template <typename T, typename R = Buffer<T>>
 struct Vec;
-template <typename L, typename R, typename Trait = BinaryTrait>
+template <typename L, typename R, typename BTrait = BinaryTrait>
 struct BinaryOperation;
-template <typename I, typename Trait = UnaryTrait>
+template <typename I, typename UTrait = UnaryTrait>
 struct UnaryOperation;
 
 template <typename T> struct ExtractDataType;
diff --git a/inst/include/etr_bits/Core/Utils.hpp b/inst/include/etr_bits/Core/Utils.hpp
index 20cb3d2..a8c26df 100644
--- a/inst/include/etr_bits/Core/Utils.hpp
+++ b/inst/include/etr_bits/Core/Utils.hpp
@@ -101,9 +101,9 @@ template <string_literal msg> inline void warn(bool inp) {
 
 struct SI {
   std::size_t sz = 0;
-  SI(const std::size_t sz) : sz(sz) {}
-  SI(const int sz) : sz(static_cast<std::size_t>(sz)) {}
-  SI(const long long sz) : sz(static_cast<std::size_t>(sz)) {}
+  SI(const std::size_t sz_) : sz(sz_) {}
+  SI(const int sz_) : sz(static_cast<std::size_t>(sz_)) {}
+  SI(const long long sz_) : sz(static_cast<std::size_t>(sz_)) {}
 };
 
 } // namespace etr
diff --git a/inst/include/etr_bits/UnaryCalculations.hpp b/inst/include/etr_bits/UnaryCalculations.hpp
index 75286cb..b980319 100644
--- a/inst/include/etr_bits/UnaryCalculations.hpp
+++ b/inst/include/etr_bits/UnaryCalculations.hpp
@@ -2,15 +2,11 @@
 #define UNARYOPERATION
 
 #include "Core.hpp"
-#include "Core/Concepts.hpp"
-#include "Core/Types.hpp"
-#include <type_traits>
 
 namespace etr {
-template <typename I, typename Trait, typename CTrait> struct UnaryOperation {
-  using RetType = typename CTrait::RetType;
-  using TypeTrait = Trait;
-  using CaseTrait = CTrait;
+template <typename I, typename UTrait> struct UnaryOperation {
+  using Trait = UTrait;
+  using RetType = typename I::RetType;
   const I &obj;
   using typeTraitObj = I;
   MatrixParameter mp;
@@ -83,7 +79,7 @@ template <typename T> auto operator-(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), MinusUnaryTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), MinusUnaryTrait>>(
         UnaryOperation<decltype(obj.d), MinusUnaryTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<double, MinusUnaryTrait>>(
@@ -95,7 +91,7 @@ template <typename T> auto sinus(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), SinusTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), SinusTrait>>(
         UnaryOperation<decltype(obj.d), SinusTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, SinusTrait>>(
@@ -112,7 +108,7 @@ template <typename T> auto sinush(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), SinusHTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), SinusHTrait>>(
         UnaryOperation<decltype(obj.d), SinusHTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, SinusHTrait>>(
@@ -129,7 +125,7 @@ template <typename T> auto asinus(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), ASinusTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), ASinusTrait>>(
         UnaryOperation<decltype(obj.d), ASinusTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, ASinusTrait>>(
@@ -146,7 +142,7 @@ template <typename T> auto cosinus(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), CosinusTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), CosinusTrait>>(
         UnaryOperation<decltype(obj.d), CosinusTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, CosinusTrait>>(
@@ -163,7 +159,7 @@ template <typename T> auto cosinush(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), CosinusHTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), CosinusHTrait>>(
         UnaryOperation<decltype(obj.d), CosinusHTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, CosinusHTrait>>(
@@ -180,7 +176,7 @@ template <typename T> auto acosinus(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), ACosinusTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), ACosinusTrait>>(
         UnaryOperation<decltype(obj.d), ACosinusTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, ACosinusTrait>>(
@@ -197,7 +193,7 @@ template <typename T> auto tangens(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), TangensTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), TangensTrait>>(
         UnaryOperation<decltype(obj.d), TangensTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, TangensTrait>>(
@@ -214,7 +210,7 @@ template <typename T> auto tangensh(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), TangensHTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), TangensHTrait>>(
         UnaryOperation<decltype(obj.d), TangensHTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, TangensHTrait>>(
@@ -231,7 +227,7 @@ template <typename T> auto atangens(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), ATangensTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), ATangensTrait>>(
         UnaryOperation<decltype(obj.d), ATangensTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, ATangensTrait>>(
@@ -248,7 +244,7 @@ template <typename T> auto ln(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), LogTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), LogTrait>>(
         UnaryOperation<decltype(obj.d), LogTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, LogTrait>>(
@@ -265,7 +261,7 @@ template <typename T> auto sqroot(const T &obj) {
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), SquareRootTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), SquareRootTrait>>(
         UnaryOperation<decltype(obj.d), SquareRootTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, SquareRootTrait>>(
@@ -283,7 +279,7 @@ auto exp(const T &obj) { // TODO: update this in the documentation
   constexpr bool isDouble = IsArithV<T>;
   if constexpr (!isDouble) {
     return Vec<typename ExtractDataType<T>::RetType,
-               UnaryOperation<decltype(obj.d), ExpTrait>, UnaryTrait>(
+               UnaryOperation<decltype(obj.d), ExpTrait>>(
         UnaryOperation<decltype(obj.d), ExpTrait>(obj.d));
   } else if constexpr (isDouble) {
     return Vec<T, UnaryOperation<T, ExpTrait>>(
diff --git a/inst/include/etr_bits/Vector/AssignmentOperator.hpp b/inst/include/etr_bits/Vector/AssignmentOperator.hpp
deleted file mode 100644
index 8f8877f..0000000
--- a/inst/include/etr_bits/Vector/AssignmentOperator.hpp
+++ /dev/null
@@ -1,293 +0,0 @@
-#ifndef ASSING2VEC_ETR_H
-#define ASSING2VEC_ETR_H
-
-#include "VectorClass.hpp"
-#include <type_traits>
-
-template <typename TD>
-  requires IsArithV<TD>
-Vec &operator=(const TD inp) {
-  static_assert(!isUnaryOP::value, "Cannot assign to unary calculation");
-  static_assert(!isBinaryOP::value, "Cannot assign to binary calculation");
-  static_assert(!isRVec::value,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
-  if constexpr (is<TD, T>) {
-    if constexpr (isSubset::value) {
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        d[i] = inp;
-      }
-#ifdef DERIV_ETR
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        deriv[i] = 0;
-      }
-#endif
-    } else if constexpr (isBorrow::value) {
-      d.sz = 1;
-      d[0] = inp;
-#ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
-#endif
-
-    } else {
-      d.resize(1);
-      d[0] = inp;
-#ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
-#endif
-    }
-    return *this;
-  } else {
-    if constexpr (isSubset::value) {
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        d[i] = static_cast<T>(inp);
-      }
-#ifdef DERIV_ETR
-      for (std::size_t i = 0; i < d.ind.size(); i++) {
-        deriv[i] = 0;
-      }
-#endif
-
-    } else if constexpr (isBorrow::value) {
-      d.sz = 1;
-      d[0] = static_cast<T>(inp);
-#ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
-#endif
-
-    } else {
-      d.resize(1);
-      d[0] = static_cast<T>(inp);
-#ifdef DERIV_ETR
-      deriv.resize(1);
-      deriv[0] = 0;
-#endif
-    }
-    return *this;
-  }
-}
-
-Vec &operator=(const Vec<T, R, Trait> &otherVec) {
-
-  static_assert(!isUnaryOP::value, "Cannot assign to unary calculation");
-  static_assert(!isBinaryOP::value, "Cannot assign to binary calculation");
-  static_assert(!isRVec::value,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
-
-  using DataTypeOtherVec = typename etr::ExtractDataType<
-      ReRef_t<decltype(otherVec)>>::RetType;
-  if constexpr (isBuffer::value) {
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    d.moveit(temp);
-  } else if constexpr (isBorrow::value) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() <= d.capacity);
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    ass<"size cannot be increased above the size of the borrowed object">(
-        d.sz <= otherVec.size());
-    d.sz = otherVec.size();
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-  } else if constexpr (isBorrowSEXP::value) {
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    if (otherVec.size() > this->size())
-      d.resize(otherVec.size());
-
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-
-  } else if constexpr (isSubset::value) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() == d.ind.size());
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    if (d.p->size() < temp.size())
-      d.resize(temp.size());
-    for (std::size_t i = 0; i < d.ind.size(); i++) {
-      d[i % d.ind.size()] = temp[i];
-    }
-  }
-  if (otherVec.d.im()) {
-    d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
-  }
-
-#ifdef DERIV_ETR
-  // TODO: what if other Vec is subsetted
-  // deriv.resize(otherVec.size());
-  // for (std::size_t i = 0; i < deriv.size(); i++) {
-  //   deriv[i] = otherVec.deriv[i];
-  // }
-  // TODO: is there something to do here?
-#endif
-
-  return *this;
-}
-
-// TODO: finish this
-template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && IS<T, T2> &&
-           isBuffer::value)
-Vec &operator=(Vec<T2, R2, Trait2> &&otherVec) {
-
-  static_assert(!isUnaryOP::value, "Cannot assign to unary calculation");
-  static_assert(!isBinaryOP::value, "Cannot assign to binary calculation");
-  static_assert(!isRVec::value,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
-  std::size_t tempSize = otherVec.size();
-  std::size_t tempCapacity = otherVec.d.capacity;
-  T *tempP = otherVec.d.p;
-  bool allocated = otherVec.d.allocated;
-
-  otherVec.d.allocated = d.allocated;
-  otherVec.d.sz = this->size();
-  otherVec.d.capacity = d.capacity;
-  otherVec.d.p = d.p;
-
-  d.allocated = allocated;
-  d.sz = tempSize;
-  d.capacity = tempCapacity;
-  d.p = tempP;
-
-  if (otherVec.d.im()) {
-    d.setMatrix(true, otherVec.nr(), otherVec.nc());
-  }
-#ifdef DERIV_ETR
-  deriv.resize(this->size());
-  for (std::size_t i = 0; i < deriv.size(); i++) {
-    deriv[i] = 0;
-  }
-#endif
-
-  return *this;
-}
-
-template <typename T2, typename R2, typename Trait2>
-Vec &operator=(const Vec<T2, R2, Trait2> &otherVec) {
-
-  static_assert(!isUnaryOP::value, "Cannot assign to unary calculation");
-  static_assert(!isBinaryOP::value, "Cannot assign to binary calculation");
-  static_assert(!isRVec::value,
-                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
-  using DataTypeOtherVec = typename etr::ExtractDataType<
-      ReRef_t<decltype(otherVec)>>::RetType;
-  using typeOtherVec = ReRef_t<decltype(otherVec)>;
-  if constexpr (isBuffer::value) {
-
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    d.moveit(temp);
-  } else if constexpr (isBorrow::value) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() <= d.capacity);
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    ass<"size cannot be increased above the size of the borrowed object">(
-        d.sz <= otherVec.size());
-    d.sz = otherVec.size();
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-  } else if constexpr (isBorrowSEXP::value) {
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    if (otherVec.size() > this->size())
-      d.resize(otherVec.size());
-
-    for (std::size_t i = 0; i < otherVec.size(); i++)
-      d[i] = temp[i];
-
-  } else if constexpr (isSubset::value) {
-    ass<"number of items to replace is not a multiple of replacement length">(
-        otherVec.size() == d.ind.size());
-    temp.resize(otherVec.size());
-    for (std::size_t i = 0; i < otherVec.size(); i++) {
-      if constexpr (is<DataTypeOtherVec, T>) {
-        temp[i] = otherVec[i];
-      } else {
-        temp[i] = static_cast<T>(otherVec[i]);
-      }
-    }
-    for (std::size_t i = 0; i < d.ind.size(); i++) {
-      d[i % d.ind.size()] = temp[i];
-    }
-  }
-  if (otherVec.d.im()) {
-    d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
-  }
-
-#ifdef DERIV_ETR
-  if constexpr (IsRVec<const Vec<T2, R2, Trait2>> ||
-                Operation<decltype(otherVec.d)>) {
-    deriv.resize(this->size());
-    // for (std::size_t i = 0; i < deriv.size(); i++) {
-    //   deriv[i] = 0;
-    // }
-  } else {
-    // deriv.resize(otherVec.size());
-    // for (std::size_t i = 0; i < deriv.sz; i++) {
-    //   deriv[i] = otherVec.deriv[i];
-    // }
-  }
-#endif
-
-  return *this;
-}
-
-#ifdef STANDALONE_ETR
-#else
-Vec &operator=(SEXP s) {
-  d.initSEXP(s);
-#ifdef DERIV_ETR
-  deriv.resize(d.sz);
-  deriv.fill(0.0);
-#endif
-  return *this;
-}
-#endif
-#endif
diff --git a/inst/include/etr_bits/Vector/Constructors.hpp b/inst/include/etr_bits/Vector/Constructors.hpp
deleted file mode 100644
index 73a638c..0000000
--- a/inst/include/etr_bits/Vector/Constructors.hpp
+++ /dev/null
@@ -1,486 +0,0 @@
-#ifndef CONSTRUCTORS_H
-#define CONSTRUCTORS_H
-
-#include "VectorClass.hpp"
-
-template <typename T2> Vec(T2 n) = delete;
-
-#ifdef DERIV_ETR
-
-// TODO: maybe for some constructors the deriv.allocated can be set to false
-// instead of allocating
-
-// NOTE: define Vector with specific size
-explicit Vec(SI &sz) : d(sz.sz), deriv(sz.sz) {}
-explicit Vec(SI &&sz) : d(sz.sz), deriv(sz.sz) {}
-
-// NOTE: Buffer
-template <typename L2>
-explicit Vec(const Buffer<L2> &&inp) : d(inp), deriv(inp) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2>
-explicit Vec(const Buffer<L2> &inp) : d(inp), deriv(inp) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename TraitOther>
-explicit Vec(const Buffer<L2, TraitOther> &inp) : d(inp), deriv(inp) {
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: Borrow
-template <typename U = R, typename T2>
-  requires IS<U, Borrow<BaseType>>
-explicit Vec(const Borrow<T2> &&borrowed) : d(borrowed), deriv(borrowed.sz) {
-  d.setMatrix(borrowed.mp);
-}
-template <typename U = R, typename T2>
-  requires IS<U, Borrow<T>>
-explicit Vec(const Borrow<T2> &borrowed) : d(borrowed), deriv(borrowed.sz) {
-  d.setMatrix(borrowed.mp);
-}
-template <typename U = R>
-  requires IS<U, Borrow<T>>
-explicit Vec(T *ptr, std::size_t s) : d(ptr, s), deriv(s) {}
-
-// NOTE: BorrowSEXP
-#ifdef STANDALONE_ETR
-#else
-template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
-explicit Vec(SEXP &&inp) = delete;
-
-template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
-explicit Vec(SEXP inp) : d(inp) {
-  deriv.resize(d.sz);
-  deriv.fill(0.0);
-}
-#endif
-
-// NOTE: Subset
-template <typename L2>
-explicit Vec(const Subset<L2> &&inp) : d(inp), deriv(inp.size()) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2>
-explicit Vec(Subset<L2> &inp) : d(inp), deriv(inp.size()) {
-  d.setMatrix(inp.mp);
-}
-// NOTE: Subset lazy
-template <typename L2, typename R2, typename TraitL>
-  requires IS<TraitL, SubsetClassTrait>
-explicit Vec(const SubsetClass<L2, R2, TraitL> &&inp)
-    : d(inp), deriv(inp.size()) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename R2, typename TraitL>
-  requires IS<TraitL, SubsetClassTrait>
-explicit Vec(SubsetClass<L2, R2, TraitL> &inp) : d(inp), deriv(inp.size()) {
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: Binary operation
-template <typename L2, typename R2, typename OperationTrait>
-explicit Vec(const BinaryOperation<L2, R2, OperationTrait> &&inp)
-    : d(inp), deriv(inp.size()) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename R2, typename OperationTrait,
-          typename DetailTrait> // NOTE: only for comparison!
-explicit Vec(const BinaryOperation<L2, R2, OperationTrait, DetailTrait> &&inp)
-    : d(inp), deriv(inp.size()) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename R2, typename OperationTrait>
-explicit Vec(BinaryOperation<L2, R2, OperationTrait> &inp)
-    : d(inp), deriv(inp.size()) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: Unary operation
-template <typename L2, typename OperationTrait>
-explicit Vec(const UnaryOperation<L2, OperationTrait> &&inp)
-    : d(inp), deriv(inp.size()) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename OperationTrait>
-explicit Vec(UnaryOperation<L2, OperationTrait> &inp)
-    : d(inp), deriv(inp.size()) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: arithmetic constructors
-explicit Vec(int sz) : d(1), deriv(1) { d[0] = static_cast<T>(sz); }
-explicit Vec(std::size_t sz) : d(1), deriv(1) { d[0] = sz; }
-Vec(double sz) : d(1), deriv(1) { d[0] = sz; }
-#ifdef STANDALONE_ETR
-Vec(bool b) : d(1), deriv(1) { d[0] = static_cast<T>(b); }
-#else
-// Vec(Rboolean b) : d(1), deriv(1) { d[0] = static_cast<T>(b); }
-#endif
-
-// NOTE: empty vector
-explicit Vec() : d(), deriv() {}
-
-// NOTE: matrix constructors
-explicit Vec(std::size_t rows, std::size_t cols)
-    : d(rows * cols), deriv(rows * cols) {
-  d.setMatrix(true, rows, cols);
-}
-explicit Vec(std::size_t rows, std::size_t cols, const double value)
-    : d(rows * cols), deriv(rows * cols) {
-  d.setMatrix(true, rows, cols);
-  d.fill(value);
-}
-// NOTE: other vector which is not of type RVec and has to be copied
-template <typename T2, typename R2, typename Trait2>
-  requires IsVec<const Vec<T2, R2, Trait2>>
-Vec(const Vec<T2, R2, Trait2> &&other_vec) {
-  using TypeTrait = Trait2;
-  using CaseTrait = Trait2;
-  if constexpr (isBorrow::value) {
-    ass<"Sizes do not match">(d.sz <=
-                              other_vec.size()); // FIX: is this correct?
-    d.sz = other_vec.size();
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  } else {
-    if (d.sz < other_vec.size()) {
-      this->d.resize(other_vec.size());
-    } else {
-      d.sz = other_vec.size();
-    }
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  }
-  if (d.sz >= 1) {
-    deriv.resize(d.sz);
-    deriv.fill(1.0);
-  }
-}
-
-// NOTE: other vector which is of type RVec and has different base type
-template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && !IS<T, T2>)
-Vec(const Vec<T2, R2, Trait2> &&other_vec) {
-  using TypeTrait = Trait2;
-  using CaseTrait = Trait2;
-  if constexpr (isBorrow::value) {
-    ass<"Sizes do not match">(d.sz <= other_vec.size());
-    d.sz = other_vec.size();
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  } else {
-    if (d.sz < other_vec.size()) {
-      this->d.resize(other_vec.size());
-    } else {
-      d.sz = other_vec.size();
-    }
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  }
-  if (d.sz >= 1) {
-    deriv.resize(d.sz);
-    this->indep_var = other_vec.indep_var;
-    deriv.fill(0.0);
-  }
-}
-
-// NOTE: other vector which is of type RVec and with same base type
-template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && IS<T, T2>)
-Vec(Vec<T2, R2, Trait2> &&other_vec) {
-  using TypeTrait = Trait2;
-  using CaseTrait = Trait2;
-  if constexpr (isBorrow::value) {
-    ass<"Sizes do not match">(d.sz <= other_vec.size());
-    d.sz = other_vec.size();
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  } else {
-    std::size_t tempSize = other_vec.size();
-    d.allocated = other_vec.d.allocated;
-    other_vec.d.sz = this->size();
-    d.sz = tempSize;
-    T *tempP = other_vec.d.p;
-    other_vec.d.p = d.p;
-    d.p = tempP;
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  }
-  if (d.sz >= 1) {
-    deriv.resize(d.sz);
-    deriv.fill(0.0);
-  }
-}
-
-// NOTE: pointer constructor
-Vec(T *ptr, std::size_t size) : d(size), deriv(size) {
-  if constexpr (isBorrow::value) {
-    d.init(ptr, size);
-  } else if constexpr (isBuffer::value) {
-    for (std::size_t i = 0; i < size; i++)
-      d[i] = ptr[i];
-    d.setMatrix(false, 0, 0);
-  }
-  deriv.fill(0.0);
-}
-Vec(BaseType *ptr, std::size_t rows, std::size_t cols)
-    : d(rows * cols), deriv(rows * cols) {
-  for (std::size_t i = 0; i < d.size(); i++)
-    d[i] = ptr[i];
-  d.setMatrix(true, rows, cols);
-  deriv.fill(0.0);
-}
-
-#else
-// NOTE: define Vector with specific size
-explicit Vec(SI &sz) : d(sz.sz) {}
-explicit Vec(SI &&sz) : d(sz.sz) {}
-
-// NOTE: Buffer
-template <typename L2> explicit Vec(const Buffer<L2> &&inp) : d(inp) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2> explicit Vec(const Buffer<L2> &inp) : d(inp) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename TraitOther>
-explicit Vec(const Buffer<L2, TraitOther> &inp) : d(inp) {
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: Borrow
-template <typename U = R, typename T2>
-  requires IS<U, Borrow<BaseType>>
-explicit Vec(const Borrow<T2> &&borrowed) : d(borrowed) {
-  d.setMatrix(borrowed.mp);
-}
-template <typename U = R, typename T2>
-  requires IS<U, Borrow<T>>
-explicit Vec(const Borrow<T2> &borrowed) : d(borrowed) {
-  d.setMatrix(borrowed.mp);
-}
-template <typename U = R>
-  requires IS<U, Borrow<T>>
-explicit Vec(T *ptr, std::size_t s) : d(ptr, s) {}
-
-// NOTE: BorrowSEXP
-#ifdef STANDALONE_ETR
-#else
-template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
-explicit Vec(SEXP &&inp) = delete;
-
-template <typename U = R>
-  requires IS<U, BorrowSEXP<T>>
-explicit Vec(SEXP inp) : d(inp) {}
-#endif
-
-// NOTE: Subset
-template <typename L2> explicit Vec(const Subset<L2> &&inp) : d(inp) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2> explicit Vec(Subset<L2> &inp) : d(inp) {
-  d.setMatrix(inp.mp);
-}
-// NOTE: Subset lazy
-template <typename L2, typename R2, typename TraitL>
-  requires IS<TraitL, SubsetClassTrait>
-explicit Vec(const SubsetClass<L2, R2, TraitL> &&inp) : d(std::move(inp)) {
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename R2, typename TraitL>
-  requires IS<TraitL, SubsetClassTrait>
-explicit Vec(SubsetClass<L2, R2, TraitL> &inp) : d(std::move(inp)) {
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: Binary operation
-template <typename L2, typename R2, typename OperationTrait>
-explicit Vec(const BinaryOperation<L2, R2, OperationTrait> &&inp) : d(inp) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename R2, typename OperationTrait,
-          typename DetailTrait> // NOTE: only for comparison!
-explicit Vec(const BinaryOperation<L2, R2, OperationTrait, DetailTrait> &&inp)
-    : d(inp) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename R2, typename OperationTrait>
-explicit Vec(BinaryOperation<L2, R2, OperationTrait> &inp) : d(inp) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: Unary operation
-template <typename L2, typename OperationTrait>
-explicit Vec(const UnaryOperation<L2, OperationTrait> &&inp) : d(inp) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-template <typename L2, typename OperationTrait>
-explicit Vec(UnaryOperation<L2, OperationTrait> &inp) : d(inp) {
-  using TypeTrait = OperationTrait;
-  d.setMatrix(inp.mp);
-}
-
-// NOTE: arithmetic constructors
-explicit Vec(int sz) : d(1) { d[0] = static_cast<T>(sz); }
-explicit Vec(std::size_t sz) : d(1) { d[0] = sz; }
-Vec(double sz) : d(1) { d[0] = sz; }
-#ifdef STANDALONE_ETR
-Vec(bool b) : d(1) { d[0] = static_cast<T>(b); }
-#else
-// Vec(Rboolean b) : d(1) { d[0] = static_cast<T>(b); }
-#endif
-
-// NOTE: empty vector
-explicit Vec() : d() {}
-
-// NOTE: matrix constructors
-explicit Vec(std::size_t rows, std::size_t cols) : d(rows * cols) {
-  d.setMatrix(true, rows, cols);
-}
-explicit Vec(std::size_t rows, std::size_t cols, const double value)
-    : d(rows * cols) {
-  d.setMatrix(true, rows, cols);
-  d.fill(value);
-}
-// NOTE: other vector which is not of type RVec and has to be copied
-template <typename T2, typename R2, typename Trait2>
-  requires IsVec<const Vec<T2, R2, Trait2>>
-Vec(const Vec<T2, R2, Trait2> &&other_vec) {
-  using TypeTrait = Trait2;
-  using CaseTrait = Trait2;
-  if constexpr (isBorrow::value) {
-    ass<"Sizes do not match">(d.sz <=
-                              other_vec.size()); // FIX: is this correct?
-    d.sz = other_vec.size();
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  } else {
-    if (d.sz < other_vec.size()) {
-      this->d.resize(other_vec.size());
-    } else {
-      d.sz = other_vec.size();
-    }
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  }
-}
-
-// NOTE: other vector which is of type RVec and has different base type
-template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && !IS<T, T2>)
-Vec(const Vec<T2, R2, Trait2> &&other_vec) {
-  using TypeTrait = Trait2;
-  using CaseTrait = Trait2;
-  if constexpr (isBorrow::value) {
-    ass<"Sizes do not match">(d.sz <= other_vec.size());
-    d.sz = other_vec.size();
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  } else {
-    if (d.sz < other_vec.size()) {
-      this->d.resize(other_vec.size());
-    } else {
-      d.sz = other_vec.size();
-    }
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  }
-}
-
-// NOTE: other vector which is of type RVec and with same base type
-template <typename T2, typename R2, typename Trait2>
-  requires(IsRVec<const Vec<T2, R2, Trait2>> && IS<T, T2>)
-Vec(Vec<T2, R2, Trait2> &&other_vec) {
-  using TypeTrait = Trait2;
-  using CaseTrait = Trait2;
-  if constexpr (isBorrow::value) {
-    ass<"Sizes do not match">(d.sz <= other_vec.size());
-    d.sz = other_vec.size();
-    for (std::size_t i = 0; i < d.size(); i++) {
-      d[i] = other_vec[i];
-    }
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  } else {
-    std::size_t tempSize = other_vec.size();
-    d.allocated = other_vec.d.allocated;
-    other_vec.d.sz = this->size();
-    d.sz = tempSize;
-    T *tempP = other_vec.d.p;
-    other_vec.d.p = d.p;
-    d.p = tempP;
-    if (other_vec.d.im()) {
-      d.setMatrix(true, other_vec.nr(), other_vec.nc());
-    }
-  }
-}
-
-// NOTE: pointer constructor
-Vec(T *ptr, std::size_t size) : d(size) {
-  if constexpr (isBorrow::value) {
-    d.init(ptr, size);
-  } else if constexpr (isBuffer::value) {
-    for (std::size_t i = 0; i < size; i++)
-      d[i] = ptr[i];
-    d.setMatrix(false, 0, 0);
-  }
-}
-Vec(BaseType *ptr, std::size_t rows, std::size_t cols) : d(rows * cols) {
-  for (std::size_t i = 0; i < d.size(); i++)
-    d[i] = ptr[i];
-  d.setMatrix(true, rows, cols);
-}
-#endif
-
-#endif
diff --git a/inst/include/etr_bits/Vector/VectorClass.hpp b/inst/include/etr_bits/Vector/VectorClass.hpp
index 7fdc0f3..01ade64 100644
--- a/inst/include/etr_bits/Vector/VectorClass.hpp
+++ b/inst/include/etr_bits/Vector/VectorClass.hpp
@@ -3,14 +3,6 @@
 
 #include "../Core.hpp"
 
-#include "../Allocation.hpp"
-#include "../BinaryCalculations.hpp"
-
-#include "../SEXPConversions.hpp"
-#include "../UnaryCalculations.hpp"
-
-#include "../Subsetting/LazySubsetting.hpp"
-
 namespace etr {
 
 template <typename T, typename R> struct Vec {
@@ -22,25 +14,757 @@ template <typename T, typename R> struct Vec {
   Buffer<T> temp;
   using DType = R;
   using RetType = typename ReRef<decltype(d)>::type::RetType;
-  using typeTraitD =
-      typename ReRef<decltype(d)>::type::TypeTrait;
-  using isBuffer = typename std::is_same<typeTraitD, BufferTrait>;
-  using isBorrow = typename std::is_same<typeTraitD, BorrowTrait>;
-  using isBorrowSEXP = typename std::is_same<typeTraitD, BorrowSEXPTrait>;
-  using isSubset = typename std::is_same<typeTraitD, SubsetTrait>;
-  using isSubsetClass = typename std::is_same<typeTraitD, SubsetClassTrait>;
-  using isVarPointer = typename std::is_same<typeTraitD, VarPointerTrait>;
-  using caseTraitD =
-      typename ReRef<decltype(d)>::type::CaseTrait;
-  using isUnaryOP = typename std::is_same<caseTraitD, UnaryTrait>;
-  using isBinaryOP = typename std::is_same<caseTraitD, BinaryTrait>;
-  using isRVec = typename std::is_same<CaseTrait, RVecTrait>;
-  using isVariableType = typename std::is_same<CaseTrait, VariableTypeTrait>;
-
-  RetType getRetType() const { return RetType{}; }
-
-#include "AssignmentOperator.hpp"
-#include "Constructors.hpp"
+
+
+  template <typename T2> Vec(T2 n) = delete;
+
+#ifdef DERIV_ETR
+
+  // TODO: maybe for some constructors the deriv.allocated can be set to false
+  // instead of allocating
+
+  // NOTE: define Vector with specific size
+  explicit Vec(SI &sz) : d(sz.sz), deriv(sz.sz) {}
+  explicit Vec(SI &&sz) : d(sz.sz), deriv(sz.sz) {}
+
+  // NOTE: Buffer
+  template <typename L2>
+  explicit Vec(const Buffer<L2> &&inp) : d(inp), deriv(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2>
+  explicit Vec(const Buffer<L2> &inp) : d(inp), deriv(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename TraitOther>
+  explicit Vec(const Buffer<L2, TraitOther> &inp) : d(inp), deriv(inp) {
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: Borrow
+  template <typename U = R, typename T2>
+  requires IS<U, Borrow<BaseType>>
+  explicit Vec(const Borrow<T2> &&borrowed) : d(borrowed), deriv(borrowed.sz) {
+    d.setMatrix(borrowed.mp);
+  }
+  template <typename U = R, typename T2>
+  requires IS<U, Borrow<T>>
+  explicit Vec(const Borrow<T2> &borrowed) : d(borrowed), deriv(borrowed.sz) {
+    d.setMatrix(borrowed.mp);
+  }
+  template <typename U = R>
+  requires IS<U, Borrow<T>>
+  explicit Vec(T *ptr, std::size_t s) : d(ptr, s), deriv(s) {}
+
+  // NOTE: BorrowSEXP
+#ifdef STANDALONE_ETR
+#else
+  template <typename U = R>
+  requires IS<U, BorrowSEXP<T>>
+  explicit Vec(SEXP &&inp) = delete;
+
+  template <typename U = R>
+  requires IS<U, BorrowSEXP<T>>
+  explicit Vec(SEXP inp) : d(inp) {
+    deriv.resize(d.sz);
+    deriv.fill(0.0);
+  }
+#endif
+
+  // NOTE: Subset
+  template <typename L2>
+  explicit Vec(const Subset<L2> &&inp) : d(inp), deriv(inp.size()) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2>
+  explicit Vec(Subset<L2> &inp) : d(inp), deriv(inp.size()) {
+    d.setMatrix(inp.mp);
+  }
+  // NOTE: Subset lazy
+  template <typename L2, typename R2, typename TraitInp>
+  requires IS<TraitInp, SubsetClassTrait>
+  explicit Vec(const SubsetClass<L2, R2, TraitInp> &&inp)
+  : d(inp), deriv(inp.size()) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename R2, typename TraitInp>
+  requires IS<TraitInp, SubsetClassTrait>
+  explicit Vec(SubsetClass<L2, R2, TraitInp> &inp) : d(inp), deriv(inp.size()) {
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: Binary operation
+  template <typename L2, typename R2, typename OperationTrait>
+  requires IsBinaryOperation<BinaryOperation<L2, R2, OperationTrait>>
+  explicit Vec(const BinaryOperation<L2, R2, OperationTrait> &&inp)
+  : d(inp), deriv(inp.size()) {
+    using TypeTrait = OperationTrait;
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename R2, typename OperationTrait,
+  typename DetailTrait> // NOTE: only for comparison!
+  explicit Vec(const BinaryOperation<L2, R2, OperationTrait, DetailTrait> &&inp)
+  : d(inp), deriv(inp.size()) {
+    using TypeTrait = OperationTrait;
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename R2, typename OperationTrait>
+  explicit Vec(BinaryOperation<L2, R2, OperationTrait> &inp)
+  : d(inp), deriv(inp.size()) {
+    using TypeTrait = OperationTrait;
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: Unary operation
+  template <typename L2, typename OperationTrait>
+  explicit Vec(const UnaryOperation<L2, OperationTrait> &&inp)
+  : d(inp), deriv(inp.size()) {
+    using TypeTrait = OperationTrait;
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename OperationTrait>
+  explicit Vec(UnaryOperation<L2, OperationTrait> &inp)
+  : d(inp), deriv(inp.size()) {
+    using TypeTrait = OperationTrait;
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: arithmetic constructors
+  explicit Vec(int sz) : d(1), deriv(1) { d[0] = static_cast<T>(sz); }
+  explicit Vec(std::size_t sz) : d(1), deriv(1) { d[0] = sz; }
+  Vec(double sz) : d(1), deriv(1) { d[0] = sz; }
+#ifdef STANDALONE_ETR
+  Vec(bool b) : d(1), deriv(1) { d[0] = static_cast<T>(b); }
+#else
+  // Vec(Rboolean b) : d(1), deriv(1) { d[0] = static_cast<T>(b); }
+#endif
+
+  // NOTE: empty vector
+  explicit Vec() : d(), deriv() {}
+
+  // NOTE: matrix constructors
+  explicit Vec(std::size_t rows, std::size_t cols)
+  : d(rows * cols), deriv(rows * cols) {
+    d.setMatrix(true, rows, cols);
+  }
+  explicit Vec(std::size_t rows, std::size_t cols, const double value)
+  : d(rows * cols), deriv(rows * cols) {
+    d.setMatrix(true, rows, cols);
+    d.fill(value);
+  }
+  // NOTE: other vector which is not of type RVec and has to be copied
+  template <typename T2, typename R2, typename Trait2>
+  requires IsVec<const Vec<T2, R2, Trait2>>
+  Vec(const Vec<T2, R2, Trait2> &&other_vec) {
+    using TypeTrait = Trait2;
+    using CaseTrait = Trait2;
+    if constexpr (isBorrow::value) {
+      ass<"Sizes do not match">(d.sz <=
+                                other_vec.size()); // FIX: is this correct?
+      d.sz = other_vec.size();
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    } else {
+      if (d.sz < other_vec.size()) {
+        this->d.resize(other_vec.size());
+      } else {
+        d.sz = other_vec.size();
+      }
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    }
+    if (d.sz >= 1) {
+      deriv.resize(d.sz);
+      deriv.fill(1.0);
+    }
+  }
+
+  // NOTE: other vector which is of type RVec and has different base type
+  template <typename T2, typename R2, typename Trait2>
+  requires(IsRVec<const Vec<T2, R2, Trait2>> && !IS<T, T2>)
+  Vec(const Vec<T2, R2, Trait2> &&other_vec) {
+    using TypeTrait = Trait2;
+    using CaseTrait = Trait2;
+    if constexpr (isBorrow::value) {
+      ass<"Sizes do not match">(d.sz <= other_vec.size());
+      d.sz = other_vec.size();
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    } else {
+      if (d.sz < other_vec.size()) {
+        this->d.resize(other_vec.size());
+      } else {
+        d.sz = other_vec.size();
+      }
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    }
+    if (d.sz >= 1) {
+      deriv.resize(d.sz);
+      this->indep_var = other_vec.indep_var;
+      deriv.fill(0.0);
+    }
+  }
+
+  // NOTE: other vector which is of type RVec and with same base type
+  template <typename T2, typename R2, typename Trait2>
+  requires(IsRVec<const Vec<T2, R2, Trait2>> && IS<T, T2>)
+  Vec(Vec<T2, R2, Trait2> &&other_vec) {
+    using TypeTrait = Trait2;
+    using CaseTrait = Trait2;
+    if constexpr (isBorrow::value) {
+      ass<"Sizes do not match">(d.sz <= other_vec.size());
+      d.sz = other_vec.size();
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    } else {
+      std::size_t tempSize = other_vec.size();
+      d.allocated = other_vec.d.allocated;
+      other_vec.d.sz = this->size();
+      d.sz = tempSize;
+      T *tempP = other_vec.d.p;
+      other_vec.d.p = d.p;
+      d.p = tempP;
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    }
+    if (d.sz >= 1) {
+      deriv.resize(d.sz);
+      deriv.fill(0.0);
+    }
+  }
+
+  // NOTE: pointer constructor
+  Vec(T *ptr, std::size_t size) : d(size), deriv(size) {
+    if constexpr (isBorrow::value) {
+      d.init(ptr, size);
+    } else if constexpr (isBuffer::value) {
+      for (std::size_t i = 0; i < size; i++)
+        d[i] = ptr[i];
+      d.setMatrix(false, 0, 0);
+    }
+    deriv.fill(0.0);
+  }
+  Vec(BaseType *ptr, std::size_t rows, std::size_t cols)
+  : d(rows * cols), deriv(rows * cols) {
+    for (std::size_t i = 0; i < d.size(); i++)
+      d[i] = ptr[i];
+    d.setMatrix(true, rows, cols);
+    deriv.fill(0.0);
+  }
+
+#else
+  // NOTE: define Vector with specific size
+  explicit Vec(SI &sz) : d(sz.sz) {}
+  explicit Vec(SI &&sz) : d(sz.sz) {}
+
+  // NOTE: Buffer
+  template <typename L2> explicit Vec(const Buffer<L2> &&inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2> explicit Vec(const Buffer<L2> &inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename TraitOther>
+  explicit Vec(const Buffer<L2, TraitOther> &inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: Borrow
+  template <typename U = R, typename T2>
+  requires IS<U, Borrow<BaseType>>
+  explicit Vec(const Borrow<T2> &&borrowed) : d(borrowed) {
+    d.setMatrix(borrowed.mp);
+  }
+  template <typename U = R, typename T2>
+  requires IS<U, Borrow<T>>
+  explicit Vec(const Borrow<T2> &borrowed) : d(borrowed) {
+    d.setMatrix(borrowed.mp);
+  }
+  template <typename U = R>
+  requires IS<U, Borrow<T>>
+  explicit Vec(T *ptr, std::size_t s) : d(ptr, s) {}
+
+  // NOTE: BorrowSEXP
+#ifdef STANDALONE_ETR
+#else
+  template <typename U = R>
+  requires IS<U, BorrowSEXP<T>>
+  explicit Vec(SEXP &&inp) = delete;
+
+  template <typename U = R>
+  requires IS<U, BorrowSEXP<T>>
+  explicit Vec(SEXP inp) : d(inp) {}
+#endif
+
+  // NOTE: Subset
+  template <typename L2> explicit Vec(const Subset<L2> &&inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2> explicit Vec(Subset<L2> &inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+  // NOTE: Subset lazy
+  template <typename L2, typename R2, typename TraitL>
+  requires IS<TraitL, SubsetClassTrait>
+  explicit Vec(const SubsetClass<L2, R2, TraitL> &&inp) : d(std::move(inp)) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename R2, typename TraitL>
+  requires IS<TraitL, SubsetClassTrait>
+  explicit Vec(SubsetClass<L2, R2, TraitL> &inp) : d(std::move(inp)) {
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: Binary operation
+  template <typename L2, typename R2, typename OperationTrait>
+  explicit Vec(const BinaryOperation<L2, R2, OperationTrait> &&inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename R2, typename OperationTrait>
+  explicit Vec(BinaryOperation<L2, R2, OperationTrait> &inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: Unary operation
+  template <typename L2, typename OperationTrait>
+  explicit Vec(const UnaryOperation<L2, OperationTrait> &&inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+  template <typename L2, typename OperationTrait>
+  explicit Vec(UnaryOperation<L2, OperationTrait> &inp) : d(inp) {
+    d.setMatrix(inp.mp);
+  }
+
+  // NOTE: arithmetic constructors
+  explicit Vec(int sz) : d(1) { d[0] = static_cast<T>(sz); }
+  explicit Vec(std::size_t sz) : d(1) { d[0] = sz; }
+  Vec(double sz) : d(1) { d[0] = sz; }
+#ifdef STANDALONE_ETR
+  Vec(bool b) : d(1) { d[0] = static_cast<T>(b); }
+#else
+  // Vec(Rboolean b) : d(1) { d[0] = static_cast<T>(b); }
+#endif
+
+  // NOTE: empty vector
+  explicit Vec() : d() {}
+
+  // NOTE: matrix constructors
+  explicit Vec(std::size_t rows, std::size_t cols) : d(rows * cols) {
+    d.setMatrix(true, rows, cols);
+  }
+  explicit Vec(std::size_t rows, std::size_t cols, const double value)
+  : d(rows * cols) {
+    d.setMatrix(true, rows, cols);
+    d.fill(value);
+  }
+  // NOTE: other vector which is not of type RVec and has to be copied
+  template <typename T2, typename R2, typename Trait2>
+  requires IsVec<const Vec<T2, R2>>
+  Vec(const Vec<T2, R2> &&other_vec) {
+    if constexpr (IsBorrow<R>) {
+      ass<"Sizes do not match">(d.sz <=
+                                other_vec.size()); // FIX: is this correct?
+      d.sz = other_vec.size();
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    } else {
+      if (d.sz < other_vec.size()) {
+        this->d.resize(other_vec.size());
+      } else {
+        d.sz = other_vec.size();
+      }
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    }
+  }
+
+  // NOTE: other vector which is of type RVec and has different base type
+  template <typename T2, typename R2>
+  requires(IsRVec<const Vec<T2, R2>> && !IS<T, T2>)
+  Vec(const Vec<T2, R2> &&other_vec) {
+    if constexpr (IsBorrow<R>) {
+      ass<"Sizes do not match">(d.sz <= other_vec.size());
+      d.sz = other_vec.size();
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    } else {
+      if (d.sz < other_vec.size()) {
+        this->d.resize(other_vec.size());
+      } else {
+        d.sz = other_vec.size();
+      }
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    }
+  }
+
+  // NOTE: other vector which is of type RVec and with same base type
+  template <typename T2, typename R2>
+  requires(IsRVec<const Vec<T2, R2>> && IS<T, T2>)
+  Vec(Vec<T2, R2> &&other_vec) {
+    if constexpr (IsBorrow<R>) {
+      ass<"Sizes do not match">(d.sz <= other_vec.size());
+      d.sz = other_vec.size();
+      for (std::size_t i = 0; i < d.size(); i++) {
+        d[i] = other_vec[i];
+      }
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    } else {
+      std::size_t tempSize = other_vec.size();
+      d.allocated = other_vec.d.allocated;
+      other_vec.d.sz = this->size();
+      d.sz = tempSize;
+      T *tempP = other_vec.d.p;
+      other_vec.d.p = d.p;
+      d.p = tempP;
+      if (other_vec.d.im()) {
+        d.setMatrix(true, other_vec.nr(), other_vec.nc());
+      }
+    }
+  }
+
+  // NOTE: pointer constructor
+  Vec(T *ptr, std::size_t size) : d(size) {
+    if constexpr (IsBorrow<R>) {
+      d.init(ptr, size);
+    } else if constexpr (IsLBuffer<R>) {
+      for (std::size_t i = 0; i < size; i++)
+        d[i] = ptr[i];
+      d.setMatrix(false, 0, 0);
+    }
+  }
+  Vec(BaseType *ptr, std::size_t rows, std::size_t cols) : d(rows * cols) {
+    for (std::size_t i = 0; i < d.size(); i++)
+      d[i] = ptr[i];
+    d.setMatrix(true, rows, cols);
+  }
+#endif
+
+
+// Assignments
+template <typename TD>
+  requires IsArithV<TD>
+Vec &operator=(const TD inp) {
+  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+  static_assert(!IsRBuffer<R>,
+                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+  if constexpr (is<TD, T>) {
+    if constexpr (IsSubset<R>) {
+      for (std::size_t i = 0; i < d.ind.size(); i++) {
+        d[i] = inp;
+      }
+#ifdef DERIV_ETR
+      for (std::size_t i = 0; i < d.ind.size(); i++) {
+        deriv[i] = 0;
+      }
+#endif
+    } else if constexpr (IsBorrow<R>) {
+      d.sz = 1;
+      d[0] = inp;
+#ifdef DERIV_ETR
+      deriv.resize(1);
+      deriv[0] = 0;
+#endif
+
+    } else {
+      d.resize(1);
+      d[0] = inp;
+#ifdef DERIV_ETR
+      deriv.resize(1);
+      deriv[0] = 0;
+#endif
+    }
+    return *this;
+  } else {
+    if constexpr (IsSubset<R>) {
+      for (std::size_t i = 0; i < d.ind.size(); i++) {
+        d[i] = static_cast<T>(inp);
+      }
+#ifdef DERIV_ETR
+      for (std::size_t i = 0; i < d.ind.size(); i++) {
+        deriv[i] = 0;
+      }
+#endif
+
+    } else if constexpr (IsBorrow<R>) {
+      d.sz = 1;
+      d[0] = static_cast<T>(inp);
+#ifdef DERIV_ETR
+      deriv.resize(1);
+      deriv[0] = 0;
+#endif
+
+    } else {
+      d.resize(1);
+      d[0] = static_cast<T>(inp);
+#ifdef DERIV_ETR
+      deriv.resize(1);
+      deriv[0] = 0;
+#endif
+    }
+    return *this;
+  }
+}
+
+Vec &operator=(const Vec<T, R> &otherVec) {
+  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+  static_assert(!IsRBuffer<R>,
+                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+
+  using DataTypeOtherVec = typename etr::ExtractDataType<
+      ReRef<decltype(otherVec)>>::RetType;
+  if constexpr (IsLBuffer<R>) {
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    d.moveit(temp);
+  } else if constexpr (IsBorrow<R>) {
+    ass<"number of items to replace is not a multiple of replacement length">(
+        otherVec.size() <= d.capacity);
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    ass<"size cannot be increased above the size of the borrowed object">(
+        d.sz <= otherVec.size());
+    d.sz = otherVec.size();
+    for (std::size_t i = 0; i < otherVec.size(); i++)
+      d[i] = temp[i];
+  } else if constexpr (IsBorrowSEXP<R>) {
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    if (otherVec.size() > this->size())
+      d.resize(otherVec.size());
+
+    for (std::size_t i = 0; i < otherVec.size(); i++)
+      d[i] = temp[i];
+
+  } else if constexpr (IsSubset<R>) {
+    ass<"number of items to replace is not a multiple of replacement length">(
+        otherVec.size() == d.ind.size());
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    if (d.p->size() < temp.size())
+      d.resize(temp.size());
+    for (std::size_t i = 0; i < d.ind.size(); i++) {
+      d[i % d.ind.size()] = temp[i];
+    }
+  }
+  if (otherVec.d.im()) {
+    d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
+  }
+
+#ifdef DERIV_ETR
+  // TODO: what if other Vec is subsetted
+  // deriv.resize(otherVec.size());
+  // for (std::size_t i = 0; i < deriv.size(); i++) {
+  //   deriv[i] = otherVec.deriv[i];
+  // }
+  // TODO: is there something to do here?
+#endif
+
+  return *this;
+}
+
+// TODO: finish this
+template <typename T2, typename R2>
+  requires(IsRVec<const Vec<T2, R2>> && IS<T, T2>)
+Vec &operator=(Vec<T2, R2> &&otherVec) {
+  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+  static_assert(!IsRBuffer<R>,
+                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+  std::size_t tempSize = otherVec.size();
+  std::size_t tempCapacity = otherVec.d.capacity;
+  T *tempP = otherVec.d.p;
+  bool allocated = otherVec.d.allocated;
+
+  otherVec.d.allocated = d.allocated;
+  otherVec.d.sz = this->size();
+  otherVec.d.capacity = d.capacity;
+  otherVec.d.p = d.p;
+
+  d.allocated = allocated;
+  d.sz = tempSize;
+  d.capacity = tempCapacity;
+  d.p = tempP;
+
+  if (otherVec.d.im()) {
+    d.setMatrix(true, otherVec.nr(), otherVec.nc());
+  }
+#ifdef DERIV_ETR
+  deriv.resize(this->size());
+  for (std::size_t i = 0; i < deriv.size(); i++) {
+    deriv[i] = 0;
+  }
+#endif
+
+  return *this;
+}
+
+template <typename T2, typename R2>
+Vec &operator=(const Vec<T2, R2> &otherVec) {
+  static_assert(!IsUnary<R>, "Cannot assign to unary calculation");
+  static_assert(!IsBinary<R>, "Cannot assign to binary calculation");
+  static_assert(!IsRBuffer<R>,
+                "Cannot assign to an r value. E.g. c(1, 2, 3) <- 1");
+    // TODO: replace is with IS
+  using DataTypeOtherVec = typename ReRef<decltype(otherVec.d)>::type::RetType;
+  if constexpr (IsLBuffer<R>) {
+
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    d.moveit(temp);
+  } else if constexpr (IsBorrow<R>) {
+    ass<"number of items to replace is not a multiple of replacement length">(
+        otherVec.size() <= d.capacity);
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    ass<"size cannot be increased above the size of the borrowed object">(
+        d.sz <= otherVec.size());
+    d.sz = otherVec.size();
+    for (std::size_t i = 0; i < otherVec.size(); i++)
+      d[i] = temp[i];
+  } else if constexpr (IsBorrowSEXP<R>) {
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    if (otherVec.size() > this->size())
+      d.resize(otherVec.size());
+
+    for (std::size_t i = 0; i < otherVec.size(); i++)
+      d[i] = temp[i];
+
+  } else if constexpr (IsSubset<R>) {
+    ass<"number of items to replace is not a multiple of replacement length">(
+        otherVec.size() == d.ind.size());
+    temp.resize(otherVec.size());
+    for (std::size_t i = 0; i < otherVec.size(); i++) {
+      if constexpr (is<DataTypeOtherVec, T>) {
+        temp[i] = otherVec[i];
+      } else {
+        temp[i] = static_cast<T>(otherVec[i]);
+      }
+    }
+    for (std::size_t i = 0; i < d.ind.size(); i++) {
+      d[i % d.ind.size()] = temp[i];
+    }
+  }
+  if (otherVec.d.im()) {
+    d.setMatrix(true, otherVec.d.nr(), otherVec.d.nc());
+  }
+
+#ifdef DERIV_ETR
+  if constexpr (IsRVec<const Vec<T2, R2, Trait2>> ||
+                Operation<decltype(otherVec.d)>) {
+    deriv.resize(this->size());
+    // for (std::size_t i = 0; i < deriv.size(); i++) {
+    //   deriv[i] = 0;
+    // }
+  } else {
+    // deriv.resize(otherVec.size());
+    // for (std::size_t i = 0; i < deriv.sz; i++) {
+    //   deriv[i] = otherVec.deriv[i];
+    // }
+  }
+#endif
+
+  return *this;
+}
+
+#ifdef STANDALONE_ETR
+#else
+Vec &operator=(SEXP s) {
+  d.initSEXP(s);
+#ifdef DERIV_ETR
+  deriv.resize(d.sz);
+  deriv.fill(0.0);
+#endif
+  return *this;
+}
+#endif
+
+
 
   RetType &operator[](std::size_t idx) { return d[idx]; }
   RetType operator[](std::size_t idx) const { return d[idx]; }
@@ -64,18 +788,18 @@ template <typename T, typename R> struct Vec {
   std::size_t nr() const { return d.nr(); }
 
   auto begin() const {
-    if constexpr (isSubset::value) {
+    if constexpr (IsSubset<R>) {
       return It<T>{d.p->p};
-    } else if constexpr (isSubsetClass::value) {
+    } else if constexpr (IsSubsetClass<R>) {
       return d.begin();
     } else {
       return It<T>{d.p};
     }
   }
   auto end() const {
-    if constexpr (isSubset::value) {
+    if constexpr (IsSubset<R>) {
       return It<T>{d.p->p + this->size()};
-    } else if constexpr (isSubsetClass::value) {
+    } else if constexpr (IsSubsetClass<R>) {
       return d.end();
     } else {
       return It<T>{d.p + this->size()};
@@ -190,14 +914,6 @@ template <typename T, typename R> struct Vec {
   }
 #endif
 
-  template <typename I> auto operator()(const I &idx) {
-    return subset(*this, idx);
-  }
-
-  template <typename IL, typename IR>
-  auto operator()(const IL &idxL, const IR &idxR) {
-    return subset(*this, idxL, idxR);
-  }
 };
 
 } // namespace etr