First draft for lazy subsetting

.Rbuildignore

@@ -30,3 +30,4 @@
 ^\.docs
 ^\.development
 ^index.html
+^compile_flags.txt

.development/test_evaluate.cpp

@@ -0,0 +1,12 @@
+#define STANDALONE_ETR
+// #define DERIV_ETR
+#include "../inst/include/etr.hpp"
+using namespace etr;
+
+int main() {
+  Vec<double> v = coca(1, 2, 3, 4);
+  Evaluate(v);
+  Evaluate(coca(1, 2, 3));
+  auto res = Evaluate(v + v);
+  print(res);
+}

.development/test_lazy_subsetting.cpp

@@ -0,0 +1,66 @@
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#define STANDALONE_ETR
+// #define DERIV_ETR
+#include "../inst/include/etr.hpp"
+using namespace etr;
+
+// TODO:
+// 1. Place SubsetClass in Vec --> done
+// 2. Add tests in subset_test --> done
+//  a. is rvalue --> done
+//  b. is arithmetic value --> done
+// 3. Dependent on the second test the arguments to subset_test are moved or not
+// --> done
+// 4. To ponder over:
+//  a. How to subset matrices --> overload subset function. Calculate indices
+//  and put them in SubsetClass
+//  b. Is it maybe a good idea to calculate the
+//  indices once and use them afterwards?
+
+// TODO: missing subset of subset:   auto five = subset_test(v, subset_test(v,
+// coca(1, 3)));
+
+// TODO: missing subset a 'subset of subset' with something
+// Or subset a calculation with something
+
+void test_subset_test_with_scalar() {
+  Vec<int> l = coca(1, 2, 3, 4);
+  int scalar = 2;
+  auto result1 = subset_test(l, scalar);
+  static_assert(std::is_same_v<decltype(result1), int>);
+  auto result2 = subset_test(l, 2.4);
+  static_assert(std::is_same_v<decltype(result2), int>);
+  ass<"Expected 2">(result1 == 2);
+  ass<"Expected 2">(result2 == 2);
+  auto result3 = subset_test(l, true);
+  ass<"Expected length 4">(result3.size() == 4);
+  auto result4 = subset_test(l, false);
+  ass<"Expected length 4">(result4.size() == 0);
+  try {
+    auto result = subset_test(l, 0);
+  } catch (std::exception &e) {
+    std::string expected =
+        "Error: out of boundaries --> value beyond size of vector";
+    ass(e.what() == expected, "Expected out of boundary error");
+  }
+  try {
+    auto result = subset_test(l, 0.4);
+    std::cout << result << std::endl;
+  } catch (std::exception &e) {
+    std::string expected =
+        "Error: out of boundaries --> value beyond size of vector";
+    ass(e.what() == expected, "Expected out of boundary error");
+  }
+  auto result5 = subset_test(l + l, 2);
+  ass<"Expected 4">(result5 == 4);
+  auto result6 = subset_test(l + 1, 2);
+  ass<"Expected 3">(result6 == 3);
+  auto result7 = subset_test(subset_test(l + 1, coca(1, 2)), 1);
+  ass<"Expected 2">(result7 == 2);
+  // auto result8 = subset_test(subset_test(l + 1, 1), 1); // Catched by static
+  // assert
+}
+
+int main() { test_subset_test_with_scalar(); }

R/RcppExports.R

@@ -57,6 +57,10 @@ dim_tests <- function() {
     invisible(.Call(`_ast2ast_dim_tests`))
 }
 
+test_lazy_subsets <- function() {
+    invisible(.Call(`_ast2ast_test_lazy_subsets`))
+}
+
 test_matrices <- function() {
     invisible(.Call(`_ast2ast_test_matrices`))
 }

compile_commands.json

@@ -1,8 +1,7 @@
 [
   {
     "directory": "/home/konrad/Documents/GitHub/RProjects/ast2ast_supplement/ast2ast",
-    "command": "clang++ -std=c++20 -DSTANDALONE_ETR -DDERIV_ETR ./src/BaseStore_Tests.cpp -I ./inst/include/",
-    "file": "./src/BaseStore_Tests.cpp"
+    "command": "clang++ -std=c++20 -DSTANDALONE_ETR ./.development/test_lazy_subsetting.cpp -I ./inst/include/ -I./inst/include/etr_bits/",
+    "file": "./.development/test_lazy_subsetting.cpp"
   }
 ]
-

compile_flags.txt

@@ -0,0 +1,3 @@
+-Iinst/include
+-std=c++20
+

inst/include/etr.hpp

@@ -33,6 +33,9 @@ If not see: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html#SEC4
 #include "etr_bits/Subsetting.hpp"
 #include "etr_bits/UnaryCalculations.hpp"
 
+#include "etr_bits/Subsetting/LazySubsetting.hpp"
+#include "etr_bits/Evaluate.hpp"
+
 #include "etr_bits/BufferVector.hpp"
 #include "etr_bits/Derivatives/DerivsGetAndAssign.hpp"
 typedef etr::Vec<etr::BaseType> sexp;

inst/include/etr_bits/Allocation/Colon.hpp

@@ -16,8 +16,8 @@
 const Vec is an Operation
 */
 #include "../BufferVector.hpp"
+#include "../Core/Traits.hpp"
 #include "AllocationUtils.hpp"
-#include "etr_bits/Core/Traits.hpp"
 #include <type_traits>
 
 namespace etr {

inst/include/etr_bits/BinaryCalculations.hpp

@@ -39,7 +39,7 @@ struct BinaryOperation {
     } else {
       return l.im() || r.im();
     }
-    return false; // issue: correct?
+    return false; // TODO: correct?
   }
   std::size_t nc() const {
     if constexpr (std::is_arithmetic_v<L>) {

inst/include/etr_bits/Core/Concepts.hpp

@@ -363,12 +363,10 @@ concept IsVarPointer = requires {
 };
 
 template <typename T> struct ExtractDType;
-
 template <typename T, typename R, typename Trait>
 struct ExtractDType<Vec<T, R, Trait>> {
   using type = R;
 };
-
 template <typename T> using ExtractedDType = typename ExtractDType<T>::type;
 
 template <typename T>

inst/include/etr_bits/Core/Header.hpp

@@ -20,6 +20,7 @@
 #include <math.h>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <unordered_map>

inst/include/etr_bits/Core/Traits.hpp

@@ -71,8 +71,8 @@ struct TimesDerivTrait {
   }
 
   template <typename L, typename R, typename LDeriv, typename RDeriv>
-  static inline typename std::common_type<L, R>::type fDeriv(L l, R r, LDeriv ld,
-                                                    RDeriv rd) {
+  static inline typename std::common_type<L, R>::type
+  fDeriv(L l, R r, LDeriv ld, RDeriv rd) {
     return ld * r + rd * l;
   }
 };
@@ -95,8 +95,8 @@ struct DivideDerivTrait {
   }
 
   template <typename L, typename R, typename LDeriv, typename RDeriv>
-  static inline typename std::common_type<L, R>::type fDeriv(L l, R r, LDeriv ld,
-                                                    RDeriv rd) {
+  static inline typename std::common_type<L, R>::type
+  fDeriv(L l, R r, LDeriv ld, RDeriv rd) {
     return (ld * r - l * rd) /
            std::pow(rd, 2); // TODO: add check for integral ...
   }
@@ -120,8 +120,8 @@ struct DivideByConstantDerivTrait {
   }
 
   template <typename L, typename R, typename LDeriv, typename RDeriv>
-  static inline typename std::common_type<L, R>::type fDeriv(L l, R r, LDeriv ld,
-                                                    RDeriv rd) {
+  static inline typename std::common_type<L, R>::type
+  fDeriv(L l, R r, LDeriv ld, RDeriv rd) {
     return ld / r;
   }
 };
@@ -133,8 +133,8 @@ struct PowDerivTrait {
   }
 
   template <typename L, typename R, typename LDeriv, typename RDeriv>
-  static inline typename std::common_type<L, R>::type fDeriv(L l, R r, LDeriv ld,
-                                                    RDeriv rd) {
+  static inline typename std::common_type<L, R>::type
+  fDeriv(L l, R r, LDeriv ld, RDeriv rd) {
     return r * std::pow(l, r - 1) * ld;
   }
 };
@@ -232,6 +232,8 @@ struct SinusDerivTrait {
   template <typename L> static inline L fDeriv(L l) { return cos(l); }
 };
 
+struct SubsetClassTrait {};
+
 struct PlusTrait {
   template <typename L = BaseType, typename R = BaseType>
   static inline typename std::common_type<L, R>::type f(L l, R r) {

inst/include/etr_bits/Evaluate.hpp

@@ -0,0 +1,33 @@
+#include "BufferVector.hpp"
+#include "Core.hpp"
+#include <cstddef>
+
+#ifndef EVALUATE_HPP
+#define EVALUATE_HPP
+
+
+namespace etr {
+// NOTE: evaluates a Subset or a calculation and returns the result
+// If something else is passed as argument it is forwarded
+
+template<typename T>
+inline auto Evaluate(T && obj) {
+  using CaseTrait =
+        typename std::remove_reference<decltype(obj.d)>::type::CaseTrait;
+  if constexpr(std::is_same_v<CaseTrait, UnaryTrait> ||
+    std::is_same_v<CaseTrait, BinaryTrait> ||
+    std::is_same_v<CaseTrait, SubsetClassTrait>) {
+    using RetType = typename std::remove_reference<decltype(obj)>::type::RetType;
+    Vec<RetType, Buffer<RetType, BufferTrait>, VectorTrait> res(SI{obj.size()});
+    for (size_t i = 0; i < res.size(); i++) {
+      res[i] = obj.d[i];
+    }
+    return res;
+  } else {
+    return std::forward<decltype(obj)>(obj);
+  }
+}
+
+}
+
+#endif