From d090bdc7cfc73c015d943f46d08c99d5d967e109 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 23 Mar 2019 15:49:53 +0300
Subject: [PATCH 01/10] functor for dac

---
 pysdsl/types/encodedvector.hpp | 115 +++++++++++++++++++++++----------
 1 file changed, 82 insertions(+), 33 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index 11dd297..7664db8 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -1,8 +1,10 @@
 #pragma once
 
 #include <string>
+#include <string.h>
 #include <tuple>
 #include <type_traits>
+#include <vector>
 
 #include <pybind11/pybind11.h>
 
@@ -148,33 +150,84 @@ template <class KEY_T>
 inline std::string key_to_string(KEY_T key) { return std::to_string(key); }
 
 
-template <class Sequence, typename KEY_T>
-inline
-auto add_dac_vector(py::module& m, KEY_T key,
-                    const char* doc = nullptr)
+namespace {
+
+char dprrr[] = "DPRRR";
+char dp[] = "DP";
+
+template <typename T, T t, bool = std::is_integral_v<T>>
+struct get_vector_type {};
+
+template <typename T, T t>
+struct get_vector_type<T, t, true> : sdsl::dac_vector<t>;
+
+template <>
+struct get_vector_type<const char*, dp, false> : sdsl::dac_vector_dp<>;
+
+template <>
+struct get_vector_type<const char*, dprrr, false> : sdsl::dac_vector_dp<sdsl::rrr_vector<>>;
+
+} // namespace
+
+
+class add_dac_vector_functor
 {
-    auto name = "DirectAccessibleCodesVector" + key_to_string(key);
+public:
+    constexpr add_dac_vector_functor(py::module& m, const char* doc = nullptr,
+                                                    const char* doc_dp = nullptr): 
+        m(m), doc(doc), doc_dp(doc_dp) {}
 
-    auto cls = py::class_<Sequence>(m, name.c_str()).def(py::init());
 
-    add_sizes(cls);
-    add_description(cls);
-    add_serialization(cls);
-    add_to_string(cls);
+    template <typename KEY_T, KEY_T key>
+    inline
+    decltype(auto) get_vector(std::integral_constant<KEY_T, key>) {
+        using type = get_vector_type<KEY_T, key>;
+        auto name = "DirectAccessibleCodesVector" + key_to_string(key);
 
-    add_read_access<Sequence>(cls);
-    add_std_algo<Sequence>(cls);
+        auto cls = py::class_<type>(m, name.c_str()).def(py::init());
 
-    if (doc) {
-        cls.doc() = doc; }
+        add_sizes(cls);
+        add_description(cls);
+        add_serialization(cls);
+        add_to_string(cls);
 
-    cls.def_property_readonly("levels", &Sequence::levels);
+        add_read_access<type>(cls);
+        add_std_algo<type>(cls);
 
-    m.attr("direct_accessible_codes_vector").attr("__setitem__")(key, cls);
-    m.attr("all_compressed_integer_vectors").attr("append")(cls);
+        if (doc && std::is_integral_v<KEY_T>)
+            cls.doc() = doc;
+        else if (doc_dp && !std::is_integral_v<KEY_T>)
+            cls.doc() = doc_dp;
 
-    return cls;
-}
+
+        cls.def_property_readonly("levels", &type::levels);
+
+        m.attr("direct_accessible_codes_vector").attr("__setitem__")(key, cls);
+        m.attr("all_compressed_integer_vectors").attr("append")(cls);
+
+        return cls;
+    }
+
+    template <typename KEY_T, KEY_T key, std::enable_if_t<std::is_integral_v<KEY_T>>* dummy = nullptr>
+    inline
+    decltype(auto) operator()(std::integral_constant<KEY_T, key> t)
+    {
+        return get_vector(t);
+        
+    }
+    template <typename KEY_T, KEY_T key,
+              std::enable_if_t<std::is_same_v<const char*, KEY_T>>* dummy = nullptr>
+    inline
+    decltype(auto) operator()(std::integral_constant<KEY_T, key> t) {
+        return get_vector(t).def("cost", &get_vector_type<KEY_T, key>::cost,
+                                    py::arg("n"), py::arg("m"));
+    }
+
+private:
+    py::module& m;
+    const char* doc;
+    const char* doc_dp;
+};
 
 
 auto add_encoded_vectors(py::module& m)
@@ -186,20 +239,16 @@ auto add_encoded_vectors(py::module& m)
 
     auto enc_classes = for_each_in_tuple(coders, add_enc_coders_functor(m));
     auto vlc_classes = for_each_in_tuple(coders, add_vlc_coders_functor(m));
-    auto dac_classes = std::make_tuple(
-        add_dac_vector<sdsl::dac_vector<4>>(m, 4, doc_dac_vector),
-        add_dac_vector<sdsl::dac_vector<8>>(m, 8, doc_dac_vector),
-        add_dac_vector<sdsl::dac_vector<16>>(m, 16, doc_dac_vector),
-        add_dac_vector<sdsl::dac_vector<63>>(m, 63, doc_dac_vector),
-        add_dac_vector<sdsl::dac_vector_dp<>>(m, "DP", doc_dac_vector_dp)
-            .def("cost", &sdsl::dac_vector_dp<>::cost,
-                 py::arg("n"), py::arg("m")),
-        add_dac_vector<
-            sdsl::dac_vector_dp<
-                sdsl::rrr_vector<>>>(m, "DPRRR", doc_dac_vector_dp)
-            .def("cost", &sdsl::dac_vector_dp<sdsl::rrr_vector<>>::cost,
-                 py::arg("n"), py::arg("m"))
-    );
+
+    using dac_params = std::tuple<
+        std::integral_constant<size_t, 4>,
+        std::integral_constant<size_t, 8>,
+        std::integral_constant<size_t, 16>,
+        std::integral_constant<size_t, 63>,
+        std::integral_constant<const char*, dp>,
+        std::integral_constant<const char*, dprrr>
+    >;
+    auto dac_classes = for_each_in_tuple(dac_params(), add_dac_vector_functor(m, doc_dac_vector, doc_dac_vector_dp));
 
     m.attr("DACVector") = m.attr("DirectAccessibleCodesVector4");
     m.attr("DirectAccessibleCodesVector") = m.attr(

From 5397109170a8c9bffac2d43d928094e1366c17bf Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 23 Mar 2019 16:56:28 +0300
Subject: [PATCH 02/10] replaced is_same_v with is_same::value (c++14)

---
 pysdsl/types/encodedvector.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index 7664db8..b147727 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -155,17 +155,17 @@ namespace {
 char dprrr[] = "DPRRR";
 char dp[] = "DP";
 
-template <typename T, T t, bool = std::is_integral_v<T>>
+template <typename T, T t, bool = std::is_integral<T>::value>
 struct get_vector_type {};
 
 template <typename T, T t>
-struct get_vector_type<T, t, true> : sdsl::dac_vector<t>;
+struct get_vector_type<T, t, true> : sdsl::dac_vector<t> {};
 
 template <>
-struct get_vector_type<const char*, dp, false> : sdsl::dac_vector_dp<>;
+struct get_vector_type<const char*, dp, false> : sdsl::dac_vector_dp<> {};
 
 template <>
-struct get_vector_type<const char*, dprrr, false> : sdsl::dac_vector_dp<sdsl::rrr_vector<>>;
+struct get_vector_type<const char*, dprrr, false> : sdsl::dac_vector_dp<sdsl::rrr_vector<>> {};
 
 } // namespace
 
@@ -194,9 +194,9 @@ class add_dac_vector_functor
         add_read_access<type>(cls);
         add_std_algo<type>(cls);
 
-        if (doc && std::is_integral_v<KEY_T>)
+        if (doc && std::is_integral<KEY_T>::value)
             cls.doc() = doc;
-        else if (doc_dp && !std::is_integral_v<KEY_T>)
+        else if (doc_dp && !std::is_integral<KEY_T>::value)
             cls.doc() = doc_dp;
 
 
@@ -208,7 +208,7 @@ class add_dac_vector_functor
         return cls;
     }
 
-    template <typename KEY_T, KEY_T key, std::enable_if_t<std::is_integral_v<KEY_T>>* dummy = nullptr>
+    template <typename KEY_T, KEY_T key, std::enable_if_t<std::is_integral<KEY_T>::value>* dummy = nullptr>
     inline
     decltype(auto) operator()(std::integral_constant<KEY_T, key> t)
     {
@@ -216,7 +216,7 @@ class add_dac_vector_functor
         
     }
     template <typename KEY_T, KEY_T key,
-              std::enable_if_t<std::is_same_v<const char*, KEY_T>>* dummy = nullptr>
+              typename std::enable_if<std::is_same<const char*, KEY_T>::value>::type* dummy = nullptr>
     inline
     decltype(auto) operator()(std::integral_constant<KEY_T, key> t) {
         return get_vector(t).def("cost", &get_vector_type<KEY_T, key>::cost,

From 41c896deebe4f73a2d7a7c2399cc0ea0b34e0d19 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 23 Mar 2019 18:09:38 +0300
Subject: [PATCH 03/10] string.h removed; enable_if_t -> enable_if<>::type

---
 pysdsl/types/encodedvector.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index b147727..1515e10 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -1,10 +1,8 @@
 #pragma once
 
 #include <string>
-#include <string.h>
 #include <tuple>
 #include <type_traits>
-#include <vector>
 
 #include <pybind11/pybind11.h>
 
@@ -208,7 +206,9 @@ class add_dac_vector_functor
         return cls;
     }
 
-    template <typename KEY_T, KEY_T key, std::enable_if_t<std::is_integral<KEY_T>::value>* dummy = nullptr>
+    template <typename KEY_T, KEY_T key, 
+              typename std::enable_if<
+                            std::is_integral<KEY_T>::value>::type* dummy = nullptr>
     inline
     decltype(auto) operator()(std::integral_constant<KEY_T, key> t)
     {
@@ -216,7 +216,8 @@ class add_dac_vector_functor
         
     }
     template <typename KEY_T, KEY_T key,
-              typename std::enable_if<std::is_same<const char*, KEY_T>::value>::type* dummy = nullptr>
+              typename std::enable_if<
+                            std::is_same<const char*, KEY_T>::value>::type* dummy = nullptr>
     inline
     decltype(auto) operator()(std::integral_constant<KEY_T, key> t) {
         return get_vector(t).def("cost", &get_vector_type<KEY_T, key>::cost,
@@ -248,7 +249,8 @@ auto add_encoded_vectors(py::module& m)
         std::integral_constant<const char*, dp>,
         std::integral_constant<const char*, dprrr>
     >;
-    auto dac_classes = for_each_in_tuple(dac_params(), add_dac_vector_functor(m, doc_dac_vector, doc_dac_vector_dp));
+    auto dac_classes = for_each_in_tuple(dac_params(), 
+                            add_dac_vector_functor(m, doc_dac_vector, doc_dac_vector_dp));
 
     m.attr("DACVector") = m.attr("DirectAccessibleCodesVector4");
     m.attr("DirectAccessibleCodesVector") = m.attr(

From 5b92c9f4c2490e350d6d41411120422564df60bf Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 23 Mar 2019 21:44:32 +0300
Subject: [PATCH 04/10] droneci test

---
 pysdsl/types/encodedvector.hpp | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index 1515e10..e666a4f 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -39,6 +39,14 @@ auto constexpr coders = std::make_tuple(
     std::make_tuple("Comma4", dens<128>{}, width<0>{},
         (sdsl::coder::comma<4>*) nullptr));
 
+using dac_params = std::tuple<
+    std::integral_constant<size_t, 4>,
+    std::integral_constant<size_t, 8>,
+    std::integral_constant<size_t, 16>,
+    std::integral_constant<size_t, 63>,
+    std::integral_constant<const char*, dp>,
+    std::integral_constant<const char*, dprrr>
+>;
 
 class add_enc_coders_functor
 {
@@ -210,10 +218,8 @@ class add_dac_vector_functor
               typename std::enable_if<
                             std::is_integral<KEY_T>::value>::type* dummy = nullptr>
     inline
-    decltype(auto) operator()(std::integral_constant<KEY_T, key> t)
-    {
+    decltype(auto) operator()(std::integral_constant<KEY_T, key> t) {
         return get_vector(t);
-        
     }
     template <typename KEY_T, KEY_T key,
               typename std::enable_if<
@@ -241,14 +247,7 @@ auto add_encoded_vectors(py::module& m)
     auto enc_classes = for_each_in_tuple(coders, add_enc_coders_functor(m));
     auto vlc_classes = for_each_in_tuple(coders, add_vlc_coders_functor(m));
 
-    using dac_params = std::tuple<
-        std::integral_constant<size_t, 4>,
-        std::integral_constant<size_t, 8>,
-        std::integral_constant<size_t, 16>,
-        std::integral_constant<size_t, 63>,
-        std::integral_constant<const char*, dp>,
-        std::integral_constant<const char*, dprrr>
-    >;
+
     auto dac_classes = for_each_in_tuple(dac_params(), 
                             add_dac_vector_functor(m, doc_dac_vector, doc_dac_vector_dp));
 

From 9261f1c798d12e46b0447bd421bd8d172de9e760 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 23 Mar 2019 21:50:15 +0300
Subject: [PATCH 05/10] droneci test

---
 pysdsl/types/encodedvector.hpp | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index e666a4f..dd1ce0a 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -39,14 +39,6 @@ auto constexpr coders = std::make_tuple(
     std::make_tuple("Comma4", dens<128>{}, width<0>{},
         (sdsl::coder::comma<4>*) nullptr));
 
-using dac_params = std::tuple<
-    std::integral_constant<size_t, 4>,
-    std::integral_constant<size_t, 8>,
-    std::integral_constant<size_t, 16>,
-    std::integral_constant<size_t, 63>,
-    std::integral_constant<const char*, dp>,
-    std::integral_constant<const char*, dprrr>
->;
 
 class add_enc_coders_functor
 {
@@ -247,7 +239,14 @@ auto add_encoded_vectors(py::module& m)
     auto enc_classes = for_each_in_tuple(coders, add_enc_coders_functor(m));
     auto vlc_classes = for_each_in_tuple(coders, add_vlc_coders_functor(m));
 
-
+    using dac_params = std::tuple<
+        std::integral_constant<size_t, 4>,
+        std::integral_constant<size_t, 8>,
+        std::integral_constant<size_t, 16>,
+        std::integral_constant<size_t, 63>,
+        std::integral_constant<const char*, dp>,
+        std::integral_constant<const char*, dprrr>
+    >;
     auto dac_classes = for_each_in_tuple(dac_params(), 
                             add_dac_vector_functor(m, doc_dac_vector, doc_dac_vector_dp));
 

From e11b365c041bdabae14a0984f8686b7e9efd1333 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 23 Mar 2019 22:19:37 +0300
Subject: [PATCH 06/10] add const

---
 pysdsl/types/encodedvector.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index dd1ce0a..b5fbc9a 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -150,8 +150,8 @@ inline std::string key_to_string(KEY_T key) { return std::to_string(key); }
 
 namespace {
 
-char dprrr[] = "DPRRR";
-char dp[] = "DP";
+const char dprrr[] = "DPRRR";
+const char dp[] = "DP";
 
 template <typename T, T t, bool = std::is_integral<T>::value>
 struct get_vector_type {};

From bbb8d6425319344e1ed8a3af0c1c4469362de846 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sun, 24 Mar 2019 02:52:18 +0300
Subject: [PATCH 07/10] inheritance -> using type

---
 pysdsl/types/encodedvector.hpp | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/pysdsl/types/encodedvector.hpp b/pysdsl/types/encodedvector.hpp
index b5fbc9a..bdf26a6 100644
--- a/pysdsl/types/encodedvector.hpp
+++ b/pysdsl/types/encodedvector.hpp
@@ -157,13 +157,22 @@ template <typename T, T t, bool = std::is_integral<T>::value>
 struct get_vector_type {};
 
 template <typename T, T t>
-struct get_vector_type<T, t, true> : sdsl::dac_vector<t> {};
+struct get_vector_type<T, t, true> {
+    using type = sdsl::dac_vector<t>;
+};
 
 template <>
-struct get_vector_type<const char*, dp, false> : sdsl::dac_vector_dp<> {};
+struct get_vector_type<const char*, dp, false> {
+    using type = sdsl::dac_vector_dp<>;
+};
 
 template <>
-struct get_vector_type<const char*, dprrr, false> : sdsl::dac_vector_dp<sdsl::rrr_vector<>> {};
+struct get_vector_type<const char*, dprrr, false> {
+    using type = sdsl::dac_vector_dp<sdsl::rrr_vector<>>;
+};
+
+template <typename T, T t>
+using get_vector_type_t = typename get_vector_type<T, t>::type;
 
 } // namespace
 
@@ -179,7 +188,7 @@ class add_dac_vector_functor
     template <typename KEY_T, KEY_T key>
     inline
     decltype(auto) get_vector(std::integral_constant<KEY_T, key>) {
-        using type = get_vector_type<KEY_T, key>;
+        using type = get_vector_type_t<KEY_T, key>;
         auto name = "DirectAccessibleCodesVector" + key_to_string(key);
 
         auto cls = py::class_<type>(m, name.c_str()).def(py::init());
@@ -218,7 +227,7 @@ class add_dac_vector_functor
                             std::is_same<const char*, KEY_T>::value>::type* dummy = nullptr>
     inline
     decltype(auto) operator()(std::integral_constant<KEY_T, key> t) {
-        return get_vector(t).def("cost", &get_vector_type<KEY_T, key>::cost,
+        return get_vector(t).def("cost", &get_vector_type_t<KEY_T, key>::cost,
                                     py::arg("n"), py::arg("m"));
     }
 

From 8453620469d2dcb8ab273e7306e68f1e084e8c6d Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 13 Apr 2019 03:06:29 +0300
Subject: [PATCH 08/10] rmq first commit

---
 pysdsl/types/rmq.hpp | 74 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 pysdsl/types/rmq.hpp

diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
new file mode 100644
index 0000000..e6a8c3c
--- /dev/null
+++ b/pysdsl/types/rmq.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <utility>
+
+#include <pybind11/pybind11.h>
+
+#include <sdsl/rmq_support_sparse_table.hpp>
+
+#include "operations/sizes.hpp"
+#include "operations/iteration.hpp"
+#include "util/tupletricks.hpp"
+#include "docstrings.hpp"
+#include "io.hpp"
+#include "calc.hpp"
+
+
+
+struct add_rmq_sparse_table_functor {
+    py::module& m;
+    const char* doc;
+
+    constexpr add_rmq_sparse_table_functor(py::module& m, const char* doc = nullptr)
+        : m(m), doc(doc) {}
+
+    template <typename t_rac, const char* rac_name, bool t_min>
+    decltype(auto) operator()(std::tuple<t_rac, 
+                                std::integral_constant<const char*, rac_name>, 
+                                std::integral_constant<bool, t_min>>) {
+        using T = sdsl::rmq_support_sparse_table<t_rac, t_min>;
+
+        std::string name = 
+            std::string("Range") + (t_min ? "Min" : "Max") + "QuerySparseTable_for_" + rac_name;
+
+        auto cls = py::class_<T>(m, name.c_str())
+            .def_property_readonly("size", (typename T::size_type(T::*)(void) const)& T::size)
+            .def(py::init([](const t_rac* rac) {return T(rac);}))
+            .def("__call__", (typename T::size_type(T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+    
+        add_sizes(cls);
+        add_description(cls);
+
+        // load takes two params
+        // add_serialization(cls);
+
+        return cls;
+    }
+};
+
+
+namespace RAC_names {
+    const char INT_VECTOR_NAME[] = "IntVector";
+}
+
+
+inline auto add_rmq_classes(py::module& m) {
+    m.attr("rmq_sparse_table") = py::dict();
+
+
+    using rmq_support_sparse_table_params = std::tuple<
+        std::tuple<sdsl::int_vector<>,
+                   std::integral_constant<const char*, RAC_names::INT_VECTOR_NAME>,
+                   std::integral_constant<bool, true>>,
+        std::tuple<sdsl::int_vector<>, 
+                   std::integral_constant<const char*, RAC_names::INT_VECTOR_NAME>,
+                   std::integral_constant<bool, false>>
+    >;
+
+    auto rmq_sparse_tables = for_each_in_tuple(rmq_support_sparse_table_params(), 
+                                add_rmq_sparse_table_functor(m, doc_rmq_sparse_table));
+    
+    return std::tuple_cat(rmq_sparse_tables);
+}

From 88c1da69656be7f8c38508a5260d69566b0381d7 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 13 Apr 2019 03:25:17 +0300
Subject: [PATCH 09/10] rmq as params

---
 pysdsl/types/rmq.hpp        | 13 ++++++++
 pysdsl/util/tupletricks.hpp | 64 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 76 insertions(+), 1 deletion(-)

diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index e6a8c3c..24bc322 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -53,6 +53,9 @@ namespace RAC_names {
     const char INT_VECTOR_NAME[] = "IntVector";
 }
 
+template <typename t_rac, typename t_min_ic>
+using general_rmq_sparse_table = py::class_<sdsl::rmq_support_sparse_table<t_rac, t_min_ic::value>>;
+
 
 inline auto add_rmq_classes(py::module& m) {
     m.attr("rmq_sparse_table") = py::dict();
@@ -69,6 +72,16 @@ inline auto add_rmq_classes(py::module& m) {
 
     auto rmq_sparse_tables = for_each_in_tuple(rmq_support_sparse_table_params(), 
                                 add_rmq_sparse_table_functor(m, doc_rmq_sparse_table));
+
+    ////////////// as params //////////////////////
+    using rmq_support_sparse_table_as_params = std::tuple<
+        std::tuple<sdsl::int_vector<>, std::integral_constant<bool, true>>,
+        std::tuple<sdsl::int_vector<>, std::integral_constant<bool, false>>
+    >;
+
+    auto rmq_sparse_tables_as_params = for_each_in_tuple(rmq_support_sparse_table_as_params(), 
+                                make_general_sybset_functor<general_rmq_sparse_table>(rmq_sparse_tables));
+    ///////////////////////////////////////////////
     
     return std::tuple_cat(rmq_sparse_tables);
 }
diff --git a/pysdsl/util/tupletricks.hpp b/pysdsl/util/tupletricks.hpp
index 2070080..98d7471 100644
--- a/pysdsl/util/tupletricks.hpp
+++ b/pysdsl/util/tupletricks.hpp
@@ -14,7 +14,7 @@ decltype(auto) for_each_impl(P&& t, Function&& f, std::index_sequence<Is...>) {
 
 template<typename P, typename Function, std::size_t... Is>
 constexpr
-decltype(auto) for_each_impl(P& t, Function&& f, std::index_sequence<Is...>) {
+decltype(auto) for_each_impl(const P& t, Function&& f, std::index_sequence<Is...>) {
     return std::make_tuple(f(std::get<Is>(t))...); }
 
 template<typename... T, typename Function>
@@ -27,6 +27,26 @@ constexpr
 decltype(auto) for_each(std::tuple<T...>& t, Function&& f) {
     return for_each_impl(t, f, std::index_sequence_for<T...>{}); }
 
+template<typename P, typename Function, std::size_t... Is>
+constexpr
+decltype(auto) forward_each_impl(P&& t, Function&& f, std::index_sequence<Is...>) {
+    return std::forward_as_tuple(f(std::get<Is>(t))...); }
+
+template<typename P, typename Function, std::size_t... Is>
+constexpr
+decltype(auto) forward_each_impl(const P& t, Function&& f, std::index_sequence<Is...>) {
+    return std::forward_as_tuple(f(std::get<Is>(t))...); }
+
+template<typename... T, typename Function>
+constexpr
+decltype(auto) forward_each(const std::tuple<T...>& t, Function&& f) {
+    return forward_each_impl(t, f, std::index_sequence_for<T...>{}); }
+
+template<typename... T, typename Function>
+constexpr
+decltype(auto) forward_each(std::tuple<T...>& t, Function&& f) {
+    return forward_each_impl(t, f, std::index_sequence_for<T...>{}); }
+
 }  // namespace detail
 
 
@@ -40,3 +60,45 @@ template <typename... Ts, typename F>
 constexpr
 decltype(auto) for_each_in_tuple(std::tuple<Ts...> &t, F f) {
     return detail::for_each(t, f); }
+
+template <typename... Ts, typename F>
+constexpr
+decltype(auto) forward_each_in_tuple(const std::tuple<Ts...> &t, F f) {
+    return detail::forward_each(t, f); }
+
+
+template <typename... Ts, typename F>
+constexpr
+decltype(auto) forward_each_in_tuple(std::tuple<Ts...> &t, F f) {
+    return detail::forward_each(t, f); }
+
+
+// subset functor
+template <typename T>
+struct get_template_arg {
+    using arg = T;
+};
+
+template <typename T, T N>
+struct get_template_arg<std::integral_constant<T, N>> {
+    const static T arg = N;
+};
+
+
+template <template <typename...> typename general_template, typename... Ts>
+struct GeneralSubsetFunctor {
+    std::tuple<Ts...>& tpl;
+
+    constexpr GeneralSubsetFunctor(std::tuple<Ts...>& tpl) noexcept
+        : tpl(tpl) {}
+
+    template <typename... Args>
+    auto& operator()(std::tuple<Args...>) const {
+        return std::get<general_template<Args...>>(tpl);
+    }
+};
+
+template <template <typename...> typename general_template, typename... Ts>
+auto make_general_sybset_functor(std::tuple<Ts...>& tpl) {
+    return GeneralSubsetFunctor<general_template, Ts...>(tpl);
+}

From e3dec6d8229ce679709bb8b7309aa93ff4601c43 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 13 Apr 2019 19:55:02 +0300
Subject: [PATCH 10/10] rmq sada and sct

---
 pysdsl/__init__.cpp         |   7 ++
 pysdsl/docstrings.hpp       |   4 ++
 pysdsl/types/rmq.hpp        | 138 ++++++++++++++++++++++++++++++++++--
 pysdsl/util/tupletricks.hpp |  11 ---
 4 files changed, 144 insertions(+), 16 deletions(-)

diff --git a/pysdsl/__init__.cpp b/pysdsl/__init__.cpp
index 49d3dcc..952c1b1 100644
--- a/pysdsl/__init__.cpp
+++ b/pysdsl/__init__.cpp
@@ -16,6 +16,7 @@
 #include "types/intvector.hpp"
 #include "types/suffixarray.hpp"
 #include "types/wavelet.hpp"
+#include "types/rmq.hpp"
 
 namespace py = pybind11;
 
@@ -40,6 +41,12 @@ PYBIND11_MODULE(pysdsl, m)
 
     auto csa_classes = add_csa(m);
 
+    // new
+    auto rmq_classes_tuple = add_rmq_classes(m);
+    auto& rmq_sparse_tables = std::get<0>(rmq_classes_tuple);
+    auto& rmq_sada = std::get<1>(rmq_classes_tuple);
+    auto& rmq_sct = std::get<2>(rmq_classes_tuple);
+
     for_each_in_tuple(iv_classes, make_inits_many_functor(iv_classes));
     for_each_in_tuple(iv_classes, make_inits_many_functor(enc_classes));
     for_each_in_tuple(iv_classes,
diff --git a/pysdsl/docstrings.hpp b/pysdsl/docstrings.hpp
index 5995f37..0396ca0 100644
--- a/pysdsl/docstrings.hpp
+++ b/pysdsl/docstrings.hpp
@@ -258,3 +258,7 @@ const char* doc_csa_wt(
     "A class for the Compressed Suffix Array (CSA) based on a Wavelet Tree "
     "(WT) of the Burrow Wheeler Transform of the original text."
 );
+
+const char* doc_rmq_sada("");
+
+const char* doc_rmq_sparse_table("");
diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index 24bc322..ea20149 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -7,6 +7,7 @@
 #include <pybind11/pybind11.h>
 
 #include <sdsl/rmq_support_sparse_table.hpp>
+#include <sdsl/rmq_succinct_sada.hpp>
 
 #include "operations/sizes.hpp"
 #include "operations/iteration.hpp"
@@ -17,6 +18,27 @@
 
 
 
+namespace detail {
+// adds constructors of t_rac... containers
+template <typename... t_rac> 
+typename std::enable_if<sizeof...(t_rac) == 0>::type add_rac_constructor(const auto&) {}
+
+template <typename t_rac_head, typename... t_rac_tail>
+void add_rac_constructor(auto& cls) {
+    cls.def(py::init([](const t_rac_head* rac) {
+        return typename std::remove_reference<decltype(cls)>::type::type(rac);
+    }));
+    add_rac_constructor<t_rac_tail...>(cls);
+}
+}
+
+// containers names
+namespace RAC_names {
+    const char INT_VECTOR_NAME[] = "IntVector",
+               INT16_VECTOR_NAME[] = "Int16Vector";
+}
+
+
 struct add_rmq_sparse_table_functor {
     py::module& m;
     const char* doc;
@@ -36,7 +58,10 @@ struct add_rmq_sparse_table_functor {
         auto cls = py::class_<T>(m, name.c_str())
             .def_property_readonly("size", (typename T::size_type(T::*)(void) const)& T::size)
             .def(py::init([](const t_rac* rac) {return T(rac);}))
-            .def("__call__", (typename T::size_type(T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+            .def("set_vector", &T::set_vector)
+            .def("__call__",
+                (typename T::size_type
+                    (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
     
         add_sizes(cls);
         add_description(cls);
@@ -49,13 +74,92 @@ struct add_rmq_sparse_table_functor {
 };
 
 
-namespace RAC_names {
-    const char INT_VECTOR_NAME[] = "IntVector";
-}
+struct add_rmq_sada_functor {
+    py::module& m;
+    const char* doc;
+
+    constexpr add_rmq_sada_functor(py::module& m, const char* doc = nullptr)
+        : m(m), doc(doc) {}
+
+
+    template <typename... t_rac, bool t_min>
+    decltype(auto) operator()(std::tuple<std::tuple<t_rac...>,
+                              std::integral_constant<bool, t_min>>) {
+        using T = typename std::conditional<t_min, sdsl::rmq_succinct_sada<>,
+                               typename sdsl::range_maximum_support_sada<>::type>::type;
+
+        std::string name =
+            std::string("Range") + (t_min ? "Min" : "Max") + "QuerySuccintSada";
+
+        auto cls = py::class_<T>(m, name.c_str())
+            .def_property_readonly("size", (typename T::size_type(T::*)(void) const)& T::size)
+            .def(py::init())
+            .def("__call__",
+                (typename T::size_type
+                    (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+
+        detail::add_rac_constructor<t_rac...>(cls);
+
+        add_sizes(cls);
+        add_description(cls);
+        add_serialization(cls);
+
+        return cls;
+    }
+};
+
+
+struct add_rmq_sct_functor {
+    py::module& m;
+    const char* doc;
+
+    constexpr add_rmq_sct_functor(py::module& m, const char* doc = nullptr)
+        : m(m), doc(doc) {}
+
+
+    template <typename... t_rac, bool t_min>
+    decltype(auto) operator()(std::tuple<std::tuple<t_rac...>,
+                              std::integral_constant<bool, t_min>>) {
+        using T = typename std::conditional<t_min, sdsl::rmq_succinct_sct<>,
+                               typename sdsl::range_maximum_sct<>::type>::type;
+
+        std::string name =
+            std::string("Range") + (t_min ? "Min" : "Max") + "QuerySuccintSct";
+
+        auto cls = py::class_<T>(m, name.c_str())
+            .def_property_readonly("size", (typename T::size_type(T::*)(void) const)& T::size)
+            .def(py::init())
+            .def("__call__",
+                (typename T::size_type
+                    (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+
+        detail::add_rac_constructor<t_rac...>(cls);
+
+        add_sizes(cls);
+        add_description(cls);
+        add_serialization(cls);
+
+        return cls;
+    }
+};
+
 
+// generalized (constants -> typenames) template for usage with GeneralSubsetFunctor
 template <typename t_rac, typename t_min_ic>
 using general_rmq_sparse_table = py::class_<sdsl::rmq_support_sparse_table<t_rac, t_min_ic::value>>;
 
+template <typename t_min_ic>
+using general_rmq_sada = py::class_<
+    typename std::conditional<t_min_ic::value, 
+        sdsl::rmq_succinct_sada<>, 
+        typename sdsl::range_maximum_support_sada<>::type>::type>;
+
+template <typename t_min_ic>
+using general_rmq_sct = py::class_<
+    typename std::conditional<t_min_ic::value,
+        sdsl::rmq_succinct_sct<>,
+        typename sdsl::range_maximum_sct<>::type>::type>;
+
 
 inline auto add_rmq_classes(py::module& m) {
     m.attr("rmq_sparse_table") = py::dict();
@@ -67,11 +171,35 @@ inline auto add_rmq_classes(py::module& m) {
                    std::integral_constant<bool, true>>,
         std::tuple<sdsl::int_vector<>, 
                    std::integral_constant<const char*, RAC_names::INT_VECTOR_NAME>,
+                   std::integral_constant<bool, false>>,
+        std::tuple<sdsl::int_vector<16>, 
+                   std::integral_constant<const char*, RAC_names::INT16_VECTOR_NAME>,
+                   std::integral_constant<bool, true>>,
+        std::tuple<sdsl::int_vector<16>, 
+                   std::integral_constant<const char*, RAC_names::INT16_VECTOR_NAME>,
+                   std::integral_constant<bool, false>>
+    >;
+
+    using rmq_sada_params = std::tuple<
+        std::tuple<std::tuple<sdsl::int_vector<>, sdsl::int_vector<16>>,
+                   std::integral_constant<bool, true>>,
+        std::tuple<std::tuple<sdsl::int_vector<>, sdsl::int_vector<16>>,
+                   std::integral_constant<bool, false>>
+    >;
+
+    using rmq_sct_params = std::tuple<
+        std::tuple<std::tuple<sdsl::int_vector<>, sdsl::int_vector<16>>,
+                   std::integral_constant<bool, true>>,
+        std::tuple<std::tuple<sdsl::int_vector<>, sdsl::int_vector<16>>,
                    std::integral_constant<bool, false>>
     >;
 
     auto rmq_sparse_tables = for_each_in_tuple(rmq_support_sparse_table_params(), 
                                 add_rmq_sparse_table_functor(m, doc_rmq_sparse_table));
+    auto rmq_sada_classes = for_each_in_tuple(rmq_sada_params(),
+                                add_rmq_sada_functor(m, doc_rmq_sada));
+    auto rmq_sct_classes = for_each_in_tuple(rmq_sct_params(),
+                                add_rmq_sct_functor(m, doc_rmq_sada));
 
     ////////////// as params //////////////////////
     using rmq_support_sparse_table_as_params = std::tuple<
@@ -83,5 +211,5 @@ inline auto add_rmq_classes(py::module& m) {
                                 make_general_sybset_functor<general_rmq_sparse_table>(rmq_sparse_tables));
     ///////////////////////////////////////////////
     
-    return std::tuple_cat(rmq_sparse_tables);
+    return std::make_tuple(rmq_sparse_tables, rmq_sada_classes, rmq_sct_classes);
 }
diff --git a/pysdsl/util/tupletricks.hpp b/pysdsl/util/tupletricks.hpp
index 98d7471..ebc554a 100644
--- a/pysdsl/util/tupletricks.hpp
+++ b/pysdsl/util/tupletricks.hpp
@@ -74,17 +74,6 @@ decltype(auto) forward_each_in_tuple(std::tuple<Ts...> &t, F f) {
 
 
 // subset functor
-template <typename T>
-struct get_template_arg {
-    using arg = T;
-};
-
-template <typename T, T N>
-struct get_template_arg<std::integral_constant<T, N>> {
-    const static T arg = N;
-};
-
-
 template <template <typename...> typename general_template, typename... Ts>
 struct GeneralSubsetFunctor {
     std::tuple<Ts...>& tpl;