style, rmq tests, rmq docstrings

Author: dimak24

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);

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."
+);

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)

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,27 +51,35 @@ 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);
 
         // 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,26 +95,32 @@ 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);
 
         add_sizes(cls);
         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);
 }