From 3057e78f33c1c93ba92b4406e924ebe4aac8a89a 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 1/9] 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 f0b3e7cc7a8b3ad2226df41d1a249970989bbca4 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 2/9] rmq as params

---
 pysdsl/types/rmq.hpp        | 13 +++++++++++++
 pysdsl/util/tupletricks.hpp |  1 -
 2 files changed, 13 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 a1c030f..283d66a 100644
--- a/pysdsl/util/tupletricks.hpp
+++ b/pysdsl/util/tupletricks.hpp
@@ -91,4 +91,3 @@ template <template <typename...> typename general_template, typename... Ts>
 auto make_general_subset_functor(std::tuple<Ts...>& tpl) {
     return GeneralSubsetFunctor<general_template, Ts...>(tpl);
 }
-

From 3d1d9b3e9972087e3876ed5ac847ee65f5a1a39f 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 3/9] rmq sada and sct

---
 pysdsl/__init__.cpp   |   7 +++
 pysdsl/docstrings.hpp |   4 ++
 pysdsl/types/rmq.hpp  | 138 ++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 144 insertions(+), 5 deletions(-)

diff --git a/pysdsl/__init__.cpp b/pysdsl/__init__.cpp
index 4376ce2..ff6f61d 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;
 
@@ -43,6 +44,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);
 }

From c04333bef9c98a64b494ccc9332fcee077f5c245 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 13 Apr 2019 21:35:44 +0300
Subject: [PATCH 4/9] clang auto fix

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

diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index ea20149..7f09905 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -20,15 +20,15 @@
 
 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 PybindClass, typename... t_rac> 
+typename std::enable_if<sizeof...(t_rac) == 0>::type add_rac_constructor(const PybindClass&) {}
 
-template <typename t_rac_head, typename... t_rac_tail>
-void add_rac_constructor(auto& cls) {
+template <typename PybindClass, typename t_rac_head, typename... t_rac_tail>
+void add_rac_constructor(PybindClass& cls) {
     cls.def(py::init([](const t_rac_head* rac) {
-        return typename std::remove_reference<decltype(cls)>::type::type(rac);
+        return typename PybindClass::type(rac);
     }));
-    add_rac_constructor<t_rac_tail...>(cls);
+    add_rac_constructor<PybindClass, t_rac_tail...>(cls);
 }
 }
 
@@ -98,7 +98,7 @@ struct add_rmq_sada_functor {
                 (typename T::size_type
                     (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
 
-        detail::add_rac_constructor<t_rac...>(cls);
+        detail::add_rac_constructor<decltype(cls), t_rac...>(cls);
 
         add_sizes(cls);
         add_description(cls);
@@ -133,7 +133,8 @@ struct add_rmq_sct_functor {
                 (typename T::size_type
                     (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
 
-        detail::add_rac_constructor<t_rac...>(cls);
+
+        detail::add_rac_constructor<decltype(cls), t_rac...>(cls);
 
         add_sizes(cls);
         add_description(cls);

From 83e74d393bf74504863564b98230ada796bf6310 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Wed, 17 Apr 2019 00:09:02 +0300
Subject: [PATCH 5/9] style, rmq tests, rmq docstrings

---
 pysdsl/__init__.cpp     |   1 -
 pysdsl/docstrings.hpp   |  15 ++++-
 pysdsl/test/test_rmq.py |  43 +++++++++++++++
 pysdsl/types/rmq.hpp    | 119 +++++++++++++++++++++++-----------------
 4 files changed, 124 insertions(+), 54 deletions(-)
 create mode 100644 pysdsl/test/test_rmq.py

diff --git a/pysdsl/__init__.cpp b/pysdsl/__init__.cpp
index ff6f61d..b883c15 100644
--- a/pysdsl/__init__.cpp
+++ b/pysdsl/__init__.cpp
@@ -44,7 +44,6 @@ 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);
diff --git a/pysdsl/docstrings.hpp b/pysdsl/docstrings.hpp
index 0396ca0..fa87b74 100644
--- a/pysdsl/docstrings.hpp
+++ b/pysdsl/docstrings.hpp
@@ -259,6 +259,17 @@ const char* doc_csa_wt(
     "(WT) of the Burrow Wheeler Transform of the original text."
 );
 
-const char* doc_rmq_sada("");
+const char* doc_rmq_sada(
+    "A class to support range minimum or range maximum queries on a random access container "
+    "in constant time and 4n+o(n) bits space."
+);
+
+const char* doc_rmq_sparse_table(
+    "A class to support range minimum or range maximum queries on a random access container "
+    "in constant time and O( n log^2(n) ) bits space."
+);
 
-const char* doc_rmq_sparse_table("");
+const char* doc_rmq_sct(
+    "A class to support range minimum or range maximum queries on a random access container "
+    "in constant time and 2n+o(n) bits space."
+);
diff --git a/pysdsl/test/test_rmq.py b/pysdsl/test/test_rmq.py
new file mode 100644
index 0000000..14e215a
--- /dev/null
+++ b/pysdsl/test/test_rmq.py
@@ -0,0 +1,43 @@
+from pysdsl import IntVector, Int16Vector
+
+from pysdsl import rmq_sada, rmq_sct, rmq_sparse_tables
+
+import random
+
+
+def _test_rmq(rmq_class, container_class, target):
+    cont = container_class(50)
+    a = []
+
+    for i in range(50):
+        a.append(random.randint(0, 50))
+        cont[i] = a[i]
+
+    rmq = rmq_class(cont)
+
+    for _ in range(50):
+        l = random.randint(0, 49)
+        r = random.randint(l, 49)
+
+        i = rmq(l, r)
+
+        assert(cont[i] == target(a[l:r+1]))
+
+
+def test_rmq_sada():
+    _test_rmq(rmq_sada['Min'], IntVector, min)
+    _test_rmq(rmq_sada['Max'], IntVector, max)
+    _test_rmq(rmq_sada['Min'], Int16Vector, min)
+    _test_rmq(rmq_sada['Max'], Int16Vector, max)
+
+def test_rmq_sct():
+    _test_rmq(rmq_sct['Min'], IntVector, min)
+    _test_rmq(rmq_sct['Max'], IntVector, max)
+    _test_rmq(rmq_sct['Min'], Int16Vector, min)
+    _test_rmq(rmq_sct['Max'], Int16Vector, max)
+
+def test_rmq_sparse_table():
+    _test_rmq(rmq_sparse_tables['Min_in_IntVector'], IntVector, min)
+    _test_rmq(rmq_sparse_tables['Max_in_IntVector'], IntVector, max)
+    _test_rmq(rmq_sparse_tables['Min_in_Int16Vector'], Int16Vector, min)
+    _test_rmq(rmq_sparse_tables['Max_in_Int16Vector'], Int16Vector, max)
diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index 7f09905..8b948ae 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -24,18 +24,21 @@ template <typename PybindClass, typename... t_rac>
 typename std::enable_if<sizeof...(t_rac) == 0>::type add_rac_constructor(const PybindClass&) {}
 
 template <typename PybindClass, typename t_rac_head, typename... t_rac_tail>
-void add_rac_constructor(PybindClass& cls) {
+void add_rac_constructor(PybindClass& cls)
+{
     cls.def(py::init([](const t_rac_head* rac) {
         return typename PybindClass::type(rac);
     }));
     add_rac_constructor<PybindClass, t_rac_tail...>(cls);
 }
-}
+
+} // namespace details
+
 
 // containers names
 namespace RAC_names {
-    const char INT_VECTOR_NAME[] = "IntVector",
-               INT16_VECTOR_NAME[] = "Int16Vector";
+    constexpr char INT_VECTOR_NAME[] = "IntVector",
+                   INT16_VECTOR_NAME[] = "Int16Vector";
 }
 
 
@@ -48,20 +51,21 @@ struct add_rmq_sparse_table_functor {
 
     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::integral_constant<const char*, rac_name>, 
+                                         std::integral_constant<bool, t_min>>)
+    {
+        using Table = sdsl::rmq_support_sparse_table<t_rac, t_min>;
+        using size_type = typename Table::size_type;
 
         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("set_vector", &T::set_vector)
+        auto cls = py::class_<Table>(m, name.c_str())
+            .def_property_readonly("size", (size_type(Table::*)(void) const)& Table::size)
+            .def(py::init([](const t_rac* rac) {return Table(rac);}))
+            .def("set_vector", &Table::set_vector)
             .def("__call__",
-                (typename T::size_type
-                    (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+                (size_type (Table::*)(size_type, size_type) const)& Table::operator());
     
         add_sizes(cls);
         add_description(cls);
@@ -69,6 +73,13 @@ struct add_rmq_sparse_table_functor {
         // load takes two params
         // add_serialization(cls);
 
+        cls.doc() = doc;
+
+        std::string key = std::string(t_min ? "Min" : "Max") + "_in_" + rac_name;
+
+        m.attr("rmq_sparse_tables").attr("__setitem__")(key, cls);
+        m.attr("all_rmq_classes").attr("append")(cls);
+
         return cls;
     }
 };
@@ -84,19 +95,20 @@ struct add_rmq_sada_functor {
 
     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::integral_constant<bool, t_min>>)
+    {
+        using RMQClass = typename std::conditional<t_min, sdsl::rmq_succinct_sada<>,
+                                        typename sdsl::range_maximum_support_sada<>::type>::type;
+        using size_type = typename RMQClass::size_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)
+        auto cls = py::class_<RMQClass>(m, name.c_str())
+            .def_property_readonly("size", (size_type (RMQClass::*)(void) const)& RMQClass::size)
             .def(py::init())
             .def("__call__",
-                (typename T::size_type
-                    (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+                (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator());
 
         detail::add_rac_constructor<decltype(cls), t_rac...>(cls);
 
@@ -104,6 +116,11 @@ struct add_rmq_sada_functor {
         add_description(cls);
         add_serialization(cls);
 
+        cls.doc() = doc;
+
+        m.attr("rmq_sada").attr("__setitem__")(t_min ? "Min" : "Max", cls);
+        m.attr("all_rmq_classes").attr("append")(cls);
+
         return cls;
     }
 };
@@ -119,19 +136,20 @@ struct add_rmq_sct_functor {
 
     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::integral_constant<bool, t_min>>)
+    {
+        using RMQClass = typename std::conditional<t_min, sdsl::rmq_succinct_sct<>,
+                                                typename sdsl::range_maximum_sct<>::type>::type;
+        using size_type = typename RMQClass::size_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)
+        auto cls = py::class_<RMQClass>(m, name.c_str())
+            .def_property_readonly("size", (size_type (RMQClass::*)(void) const)& RMQClass::size)
             .def(py::init())
             .def("__call__",
-                (typename T::size_type
-                    (T::*)(typename T::size_type, typename T::size_type) const)& T::operator());
+                (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator());
 
 
         detail::add_rac_constructor<decltype(cls), t_rac...>(cls);
@@ -140,31 +158,40 @@ struct add_rmq_sct_functor {
         add_description(cls);
         add_serialization(cls);
 
+        cls.doc() = doc;
+
+        m.attr("rmq_sct").attr("__setitem__")(t_min ? "Min" : "Max", cls);
+        m.attr("all_rmq_classes").attr("append")(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_rac, typename t_min_integral_constant>
+using general_rmq_sparse_table =
+    py::class_<sdsl::rmq_support_sparse_table<t_rac, t_min_integral_constant::value>>;
 
-template <typename t_min_ic>
+template <typename t_min_integral_constant>
 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>;
+    typename std::conditional<t_min_integral_constant::value, 
+                              sdsl::rmq_succinct_sada<>, 
+                              typename sdsl::range_maximum_support_sada<>::type>::type>;
 
-template <typename t_min_ic>
+template <typename t_min_integral_constant>
 using general_rmq_sct = py::class_<
-    typename std::conditional<t_min_ic::value,
-        sdsl::rmq_succinct_sct<>,
-        typename sdsl::range_maximum_sct<>::type>::type>;
-
+    typename std::conditional<t_min_integral_constant::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();
 
+inline auto add_rmq_classes(py::module& m)
+{
+    m.attr("rmq_sparse_tables") = py::dict();
+    m.attr("rmq_sada") = py::dict();
+    m.attr("rmq_sct") = py::dict();
+    m.attr("all_rmq_classes") = py::list();
 
     using rmq_support_sparse_table_params = std::tuple<
         std::tuple<sdsl::int_vector<>,
@@ -200,17 +227,7 @@ inline auto add_rmq_classes(py::module& m) {
     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<
-        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));
-    ///////////////////////////////////////////////
+                                add_rmq_sct_functor(m, doc_rmq_sct));
     
     return std::make_tuple(rmq_sparse_tables, rmq_sada_classes, rmq_sct_classes);
 }

From c07114e3c77ead5b04b349aa96c420e2edfe279a Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Thu, 18 Apr 2019 02:01:06 +0300
Subject: [PATCH 6/9] docstrings for methods

---
 pysdsl/test/test_rmq.py |  5 +++--
 pysdsl/types/rmq.hpp    | 18 +++++++++++-------
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/pysdsl/test/test_rmq.py b/pysdsl/test/test_rmq.py
index 14e215a..59c08f2 100644
--- a/pysdsl/test/test_rmq.py
+++ b/pysdsl/test/test_rmq.py
@@ -1,8 +1,9 @@
+import random
+
 from pysdsl import IntVector, Int16Vector
 
 from pysdsl import rmq_sada, rmq_sct, rmq_sparse_tables
 
-import random
 
 
 def _test_rmq(rmq_class, container_class, target):
@@ -21,7 +22,7 @@ def _test_rmq(rmq_class, container_class, target):
 
         i = rmq(l, r)
 
-        assert(cont[i] == target(a[l:r+1]))
+        assert cont[i] == target(a[l:r+1])
 
 
 def test_rmq_sada():
diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index 8b948ae..4a9ab3a 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -61,11 +61,13 @@ struct add_rmq_sparse_table_functor {
             std::string("Range") + (t_min ? "Min" : "Max") + "QuerySparseTable_for_" + rac_name;
 
         auto cls = py::class_<Table>(m, name.c_str())
-            .def_property_readonly("size", (size_type(Table::*)(void) const)& Table::size)
             .def(py::init([](const t_rac* rac) {return Table(rac);}))
-            .def("set_vector", &Table::set_vector)
+            .def("set_vector", &Table::set_vector,
+                 "Sets a vector rmq is processed on.")
             .def("__call__",
-                (size_type (Table::*)(size_type, size_type) const)& Table::operator());
+                (size_type (Table::*)(size_type, size_type) const)& Table::operator(),
+                 (std::string("Returns an index of the ") + (t_min ? "minimal" : "maximal") +
+                             " value on the segment [l,r].").c_str());
     
         add_sizes(cls);
         add_description(cls);
@@ -105,10 +107,11 @@ struct add_rmq_sada_functor {
             std::string("Range") + (t_min ? "Min" : "Max") + "QuerySuccintSada";
 
         auto cls = py::class_<RMQClass>(m, name.c_str())
-            .def_property_readonly("size", (size_type (RMQClass::*)(void) const)& RMQClass::size)
             .def(py::init())
             .def("__call__",
-                (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator());
+                (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator(),
+                 (std::string("Returns an index of the ") + (t_min ? "minimal" : "maximal") +
+                             " value on the segment [l,r].").c_str());;
 
         detail::add_rac_constructor<decltype(cls), t_rac...>(cls);
 
@@ -146,10 +149,11 @@ struct add_rmq_sct_functor {
             std::string("Range") + (t_min ? "Min" : "Max") + "QuerySuccintSct";
 
         auto cls = py::class_<RMQClass>(m, name.c_str())
-            .def_property_readonly("size", (size_type (RMQClass::*)(void) const)& RMQClass::size)
             .def(py::init())
             .def("__call__",
-                (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator());
+                (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator(),
+                 (std::string("Returns an index of the ") + (t_min ? "minimal" : "maximal") +
+                             " value on the segment [l,r].").c_str());
 
 
         detail::add_rac_constructor<decltype(cls), t_rac...>(cls);

From eba3b43b8470b86bf129bc8a3fd61829f3ae44a9 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 18 May 2019 19:40:16 +0300
Subject: [PATCH 7/9] use generated int vectors as params for rmq, improve rmq
 tests

---
 pysdsl/__init__.cpp         |  2 +-
 pysdsl/test/test_rmq.py     | 44 -------------------------
 pysdsl/types/rmq.hpp        | 44 ++++++++++++-------------
 pysdsl/util/tupletricks.hpp |  4 +--
 tests/test_rmq.py           | 65 +++++++++++++++++++++++++++++++++++++
 5 files changed, 89 insertions(+), 70 deletions(-)
 delete mode 100644 pysdsl/test/test_rmq.py
 create mode 100644 tests/test_rmq.py

diff --git a/pysdsl/__init__.cpp b/pysdsl/__init__.cpp
index b883c15..8f31801 100644
--- a/pysdsl/__init__.cpp
+++ b/pysdsl/__init__.cpp
@@ -44,7 +44,7 @@ PYBIND11_MODULE(pysdsl, m)
 
     auto csa_classes = add_csa(m);
 
-    auto rmq_classes_tuple = add_rmq_classes(m);
+    auto rmq_classes_tuple = add_rmq_classes(m, iv_classes_as_params);
     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);
diff --git a/pysdsl/test/test_rmq.py b/pysdsl/test/test_rmq.py
deleted file mode 100644
index 59c08f2..0000000
--- a/pysdsl/test/test_rmq.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import random
-
-from pysdsl import IntVector, Int16Vector
-
-from pysdsl import rmq_sada, rmq_sct, rmq_sparse_tables
-
-
-
-def _test_rmq(rmq_class, container_class, target):
-    cont = container_class(50)
-    a = []
-
-    for i in range(50):
-        a.append(random.randint(0, 50))
-        cont[i] = a[i]
-
-    rmq = rmq_class(cont)
-
-    for _ in range(50):
-        l = random.randint(0, 49)
-        r = random.randint(l, 49)
-
-        i = rmq(l, r)
-
-        assert cont[i] == target(a[l:r+1])
-
-
-def test_rmq_sada():
-    _test_rmq(rmq_sada['Min'], IntVector, min)
-    _test_rmq(rmq_sada['Max'], IntVector, max)
-    _test_rmq(rmq_sada['Min'], Int16Vector, min)
-    _test_rmq(rmq_sada['Max'], Int16Vector, max)
-
-def test_rmq_sct():
-    _test_rmq(rmq_sct['Min'], IntVector, min)
-    _test_rmq(rmq_sct['Max'], IntVector, max)
-    _test_rmq(rmq_sct['Min'], Int16Vector, min)
-    _test_rmq(rmq_sct['Max'], Int16Vector, max)
-
-def test_rmq_sparse_table():
-    _test_rmq(rmq_sparse_tables['Min_in_IntVector'], IntVector, min)
-    _test_rmq(rmq_sparse_tables['Max_in_IntVector'], IntVector, max)
-    _test_rmq(rmq_sparse_tables['Min_in_Int16Vector'], Int16Vector, min)
-    _test_rmq(rmq_sparse_tables['Max_in_Int16Vector'], Int16Vector, max)
diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index 4a9ab3a..552f036 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -35,7 +35,7 @@ void add_rac_constructor(PybindClass& cls)
 } // namespace details
 
 
-// containers names
+// containers names for sparse
 namespace RAC_names {
     constexpr char INT_VECTOR_NAME[] = "IntVector",
                    INT16_VECTOR_NAME[] = "Int16Vector";
@@ -80,7 +80,8 @@ struct add_rmq_sparse_table_functor {
         std::string key = std::string(t_min ? "Min" : "Max") + "_in_" + rac_name;
 
         m.attr("rmq_sparse_tables").attr("__setitem__")(key, cls);
-        m.attr("all_rmq_classes").attr("append")(cls);
+        m.attr((std::string("all_range_") + (t_min ? "min" : "max") + "_classes").c_str())
+            .attr("append")(cls);
 
         return cls;
     }
@@ -111,7 +112,7 @@ struct add_rmq_sada_functor {
             .def("__call__",
                 (size_type (RMQClass::*)(size_type, size_type) const)& RMQClass::operator(),
                  (std::string("Returns an index of the ") + (t_min ? "minimal" : "maximal") +
-                             " value on the segment [l,r].").c_str());;
+                              " value on the segment [l,r].").c_str());;
 
         detail::add_rac_constructor<decltype(cls), t_rac...>(cls);
 
@@ -122,7 +123,8 @@ struct add_rmq_sada_functor {
         cls.doc() = doc;
 
         m.attr("rmq_sada").attr("__setitem__")(t_min ? "Min" : "Max", cls);
-        m.attr("all_rmq_classes").attr("append")(cls);
+        m.attr((std::string("all_range_") + (t_min ? "min" : "max") + "_classes").c_str())
+            .attr("append")(cls);
 
         return cls;
     }
@@ -165,7 +167,8 @@ struct add_rmq_sct_functor {
         cls.doc() = doc;
 
         m.attr("rmq_sct").attr("__setitem__")(t_min ? "Min" : "Max", cls);
-        m.attr("all_rmq_classes").attr("append")(cls);
+        m.attr((std::string("all_range_") + (t_min ? "min" : "max") + "_classes").c_str())
+            .attr("append")(cls);
 
         return cls;
     }
@@ -190,12 +193,21 @@ using general_rmq_sct = py::class_<
                               typename sdsl::range_maximum_sct<>::type>::type>;
 
 
-inline auto add_rmq_classes(py::module& m)
+template <typename... Ts>
+static
+auto make_rmq_params(const std::tuple<py::class_<Ts>&...>& params) {
+    return std::tuple<std::tuple<std::tuple<Ts...>, std::integral_constant<bool, true>>,
+                      std::tuple<std::tuple<Ts...>, std::integral_constant<bool, false>>>();
+}
+
+
+inline auto add_rmq_classes(py::module& m, auto params)
 {
     m.attr("rmq_sparse_tables") = py::dict();
     m.attr("rmq_sada") = py::dict();
     m.attr("rmq_sct") = py::dict();
-    m.attr("all_rmq_classes") = py::list();
+    m.attr("all_range_min_classes") = py::list();
+    m.attr("all_range_max_classes") = py::list();
 
     using rmq_support_sparse_table_params = std::tuple<
         std::tuple<sdsl::int_vector<>,
@@ -212,25 +224,11 @@ inline auto add_rmq_classes(py::module& m)
                    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(),
+    auto rmq_sada_classes = for_each_in_tuple(make_rmq_params(params),
                                 add_rmq_sada_functor(m, doc_rmq_sada));
-    auto rmq_sct_classes = for_each_in_tuple(rmq_sct_params(),
+    auto rmq_sct_classes = for_each_in_tuple(make_rmq_params(params),
                                 add_rmq_sct_functor(m, doc_rmq_sct));
     
     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 283d66a..7e75823 100644
--- a/pysdsl/util/tupletricks.hpp
+++ b/pysdsl/util/tupletricks.hpp
@@ -24,7 +24,7 @@ decltype(auto) for_each(const std::tuple<T...>& t, Function&& f) {
 
 template<typename... T, typename Function>
 constexpr
-decltype(auto) for_each(std::tuple<T...>& t, Function&& f) {
+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>
@@ -58,7 +58,7 @@ decltype(auto) for_each_in_tuple(const std::tuple<Ts...> &t, F f) {
 
 template <typename... Ts, typename F>
 constexpr
-decltype(auto) for_each_in_tuple(std::tuple<Ts...> &t, F f) {
+decltype(auto) for_each_in_tuple(std::tuple<Ts...> &&t, F f) {
     return detail::for_each(t, f); }
 
 template <typename... Ts, typename F>
diff --git a/tests/test_rmq.py b/tests/test_rmq.py
new file mode 100644
index 0000000..b4ebc69
--- /dev/null
+++ b/tests/test_rmq.py
@@ -0,0 +1,65 @@
+import random
+import pytest
+
+from pysdsl import Int8Vector, Int64Vector
+from pysdsl import rmq_sada, rmq_sct
+
+
+
+
+def _test_rmq(rmq_class, container_class, target):
+    cont = container_class(50)
+    a = []
+
+    for i in range(50):
+        a.append(random.randint(0, 50))
+        cont[i] = a[i]
+
+    rmq = rmq_class(cont)
+
+    for _ in range(50):
+        l = random.randint(0, 49)
+        r = random.randint(l, 49)
+
+        i = rmq(l, r)
+
+        assert cont[i] == target(a[l:r+1])
+
+
+
+@pytest.mark.parametrize('container_class', (Int8Vector, Int64Vector))
+def test_rmq_sada(container_class):
+    _test_rmq(rmq_sada['Min'], container_class, min)
+    _test_rmq(rmq_sada['Max'], container_class, max)
+
+
+@pytest.mark.parametrize('container_class', (Int8Vector, Int64Vector))
+def test_rmq_sct(container_class):
+    _test_rmq(rmq_sct['Min'], container_class, min)
+    _test_rmq(rmq_sct['Max'], container_class, max)
+
+
+
+@pytest.mark.parametrize("rmq_class", list(rmq_sada.values()) + list(rmq_sct.values()))
+def test_rmq_on_container_remove(rmq_class):
+    cont = Int64Vector(3)
+    
+    cont[0] = 1
+    cont[1] = 2
+    cont[2] = 3
+    
+    rmq = rmq_class(cont)
+
+    ans1 = rmq(0, 2)
+
+    cont[0] = 3
+    cont[1] = 2
+    cont[2] = 1
+
+    ans2 = rmq(0, 2)
+    assert ans1 == ans2
+
+    cont = None
+
+    ans2 = rmq(0, 2)
+    assert ans1 == ans2

From 07995e75b59175cf2eed8cc0944f0c1e7d5ac723 Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 18 May 2019 19:57:56 +0300
Subject: [PATCH 8/9] fix for_each

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

diff --git a/pysdsl/util/tupletricks.hpp b/pysdsl/util/tupletricks.hpp
index 7e75823..283d66a 100644
--- a/pysdsl/util/tupletricks.hpp
+++ b/pysdsl/util/tupletricks.hpp
@@ -24,7 +24,7 @@ decltype(auto) for_each(const std::tuple<T...>& t, Function&& f) {
 
 template<typename... T, typename Function>
 constexpr
-decltype(auto) for_each(std::tuple<T...>&& t, Function&& f) {
+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>
@@ -58,7 +58,7 @@ decltype(auto) for_each_in_tuple(const std::tuple<Ts...> &t, F f) {
 
 template <typename... Ts, typename F>
 constexpr
-decltype(auto) for_each_in_tuple(std::tuple<Ts...> &&t, F f) {
+decltype(auto) for_each_in_tuple(std::tuple<Ts...> &t, F f) {
     return detail::for_each(t, f); }
 
 template <typename... Ts, typename F>

From 282ee6186af07b13304e9945ac185c01e3e3064d Mon Sep 17 00:00:00 2001
From: Dmitrii Kamaldinov <dimak24.05@mail.ru>
Date: Sat, 18 May 2019 20:03:36 +0300
Subject: [PATCH 9/9] clang auto fix

---
 pysdsl/types/rmq.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pysdsl/types/rmq.hpp b/pysdsl/types/rmq.hpp
index 552f036..724baac 100644
--- a/pysdsl/types/rmq.hpp
+++ b/pysdsl/types/rmq.hpp
@@ -201,7 +201,8 @@ auto make_rmq_params(const std::tuple<py::class_<Ts>&...>& params) {
 }
 
 
-inline auto add_rmq_classes(py::module& m, auto params)
+template <typename... Ts>
+inline auto add_rmq_classes(py::module& m, const std::tuple<py::class_<Ts>&...>& params)
 {
     m.attr("rmq_sparse_tables") = py::dict();
     m.attr("rmq_sada") = py::dict();