Skip to content

Commit 27afc2e

Browse files
author
Konstantin Podshumok
committed
rename wavelets
1 parent f15e850 commit 27afc2e

File tree

5 files changed

+250
-29
lines changed

5 files changed

+250
-29
lines changed

‎pysdsl/__init__.cpp‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -29,11 +29,14 @@ PYBIND11_MODULE(pysdsl, m)
2929
py::class_<sdsl::int_vector<1>>& bit_vector_cls = std::get<1>(iv_classes);
3030

3131
auto bit_vector_classes = std::make_tuple(bit_vector_cls);
32-
auto compressed_bit_vector_classes = add_bitvectors(m, bit_vector_cls);
32+
33+
auto tmp = add_bitvectors(m, bit_vector_cls);
34+
auto compressed_bit_vector_classes = std::get<0>(tmp);
35+
auto cbv_propagate = std::get<1>(tmp);
3336

3437
auto enc_classes = add_encoded_vectors(m);
3538

36-
auto wavelet_classes = add_wavelet(m, compressed_bit_vector_classes);
39+
auto wavelet_classes = add_wavelet(m, cbv_propagate);
3740

3841
auto csa_classes = add_csa(m);
3942

@@ -64,8 +67,8 @@ PYBIND11_MODULE(pysdsl, m)
6467

6568
for_each_in_tuple(iv_classes, make_pysequence_init_functor());
6669
for_each_in_tuple(enc_classes, make_pysequence_init_functor());
67-
68-
//for_each_in_tuple(sd_classes, make_pysequence_init_functor());
70+
//for_each_in_tuple(compressed_bit_vector_classes,
71+
// make_pysequence_init_functor());
6972

7073
for_each_in_tuple(wavelet_classes, make_pysequence_init_functor());
7174
for_each_in_tuple(csa_classes, make_pysequence_init_functor());

‎pysdsl/__init__.py‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
from pysdsl import *

‎pysdsl/types/bitvector.hpp‎

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -209,5 +209,13 @@ auto add_bitvectors(py::module& m, py::class_<B>& bit_vector_cls)
209209
add_sd_vector<sdsl::sd_vector<>>(m, "SDVectorSD"),
210210
add_sd_vector(m, std::get<1>(rrr_classes)));
211211

212-
return std::tuple_cat(bvil_classes, rrr_classes, sd_classes, hyb_classes);
212+
return std::make_tuple(
213+
std::tuple_cat(bvil_classes, rrr_classes, sd_classes, hyb_classes),
214+
std::make_tuple( // propagate
215+
std::get<2>(rrr_classes),
216+
std::get<0>(sd_classes),
217+
std::get<3>(bvil_classes)
218+
)
219+
);
220+
213221
}

‎pysdsl/types/wavelet.hpp‎

Lines changed: 228 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
#include <utility>
77
#include <vector>
88

9+
#include <sdsl/vectors.hpp>
910
#include <sdsl/wavelet_trees.hpp>
1011

1112
#include <pybind11/pybind11.h>
@@ -388,22 +389,186 @@ inline auto add_wt_int(py::module& m, std::string&& base_name)
388389
return cls;
389390
}
390391

392+
template <class bit_vector=sdsl::bit_vector>
393+
inline auto add_wm_int(py::module& m, std::string&& base_name)
394+
{
395+
auto cls = add_wavelet_class<sdsl::wm_int<bit_vector>>(
396+
m, ("WaveletMatrixInt" + base_name).c_str(), doc_wm_int);
397+
m.attr("wavelet_matrix_int").attr("__setitem__")(base_name, cls);
398+
399+
return cls;
400+
}
401+
402+
template <class bit_vector=sdsl::bit_vector>
403+
inline auto add_wt_huff(py::module& m, std::string&& base_name)
404+
{
405+
auto cls = add_wavelet_class<sdsl::wt_huff<bit_vector>>(
406+
m, ("WaveletTreeHuffman" + base_name).c_str(), doc_wt_huff);
407+
m.attr("wavelet_tree_huffman").attr("__setitem__")(base_name, cls);
408+
409+
return cls;
410+
}
411+
412+
template <class bit_vector=sdsl::bit_vector>
413+
inline auto add_wt_huff_int(py::module& m, std::string&& base_name)
414+
{
415+
auto cls = add_wavelet_class<sdsl::wt_huff_int<bit_vector>>(
416+
m, ("WaveletTreeHuffmanInt" + base_name).c_str(), doc_wt_huff);
417+
m.attr("wavelet_tree_huffman_int").attr("__setitem__")(base_name, cls);
418+
419+
return cls;
420+
}
421+
422+
423+
template <class bit_vector=sdsl::bit_vector>
424+
inline auto add_wt_hutu(py::module& m, std::string&& base_name)
425+
{
426+
auto cls = add_wavelet_class<sdsl::wt_hutu<bit_vector>>(
427+
m, ("WaveletTreeHuTucker" + base_name).c_str(), doc_wt_hutu);
428+
m.attr("wavelet_tree_hu_tucker").attr("__setitem__")(base_name, cls);
429+
430+
return cls;
431+
}
432+
433+
template <class bit_vector=sdsl::bit_vector>
434+
inline auto add_wt_hutu_int(py::module& m, std::string&& base_name)
435+
{
436+
auto cls = add_wavelet_class<sdsl::wt_hutu_int<bit_vector>>(
437+
m, ("WaveletTreeHuTuckerInt" + base_name).c_str(), doc_wt_hutu);
438+
m.attr("wavelet_tree_hu_tucker_int").attr("__setitem__")(base_name, cls);
439+
440+
return cls;
441+
}
442+
443+
444+
template <class bit_vector=sdsl::bit_vector>
445+
inline auto add_wt_blcd(py::module& m, std::string&& base_name)
446+
{
447+
auto cls = add_wavelet_class<sdsl::wt_blcd<bit_vector>>(
448+
m, ("WaveletTreeBalanced" + base_name).c_str(), doc_wt_blcd);
449+
m.attr("wavelet_tree_balanced").attr("__setitem__")(base_name, cls);
450+
451+
return cls;
452+
}
453+
454+
455+
template <class bit_vector=sdsl::bit_vector>
456+
inline auto add_wt_blcd_int(py::module& m, std::string&& base_name)
457+
{
458+
auto cls = add_wavelet_class<sdsl::wt_huff_int<bit_vector>>(
459+
m, ("WaveletTreeBalancedInt" + base_name).c_str(), doc_wt_blcd);
460+
m.attr("wavelet_tree_balanced_int").attr("__setitem__")(base_name, cls);
461+
462+
return cls;
463+
}
464+
391465

392466
template <class bit_vector=sdsl::bit_vector>
393467
inline auto add_wt_int(py::module& m, const std::string& base_name)
394468
{ return add_wt_int<bit_vector>(m, std::string(base_name)); }
395469

396470

471+
template <class bit_vector=sdsl::bit_vector>
472+
inline auto add_wm_int(py::module& m, const std::string& base_name)
473+
{ return add_wm_int<bit_vector>(m, std::string(base_name)); }
474+
475+
476+
template <class bit_vector=sdsl::bit_vector>
477+
inline auto add_wt_huff(py::module& m, const std::string& base_name)
478+
{ return add_wt_huff<bit_vector>(m, std::string(base_name)); }
479+
480+
template <class bit_vector=sdsl::bit_vector>
481+
inline auto add_wt_huff_int(py::module& m, const std::string& base_name)
482+
{ return add_wt_huff_int<bit_vector>(m, std::string(base_name)); }
483+
484+
template <class bit_vector=sdsl::bit_vector>
485+
inline auto add_wt_hutu(py::module& m, const std::string& base_name)
486+
{ return add_wt_hutu<bit_vector>(m, std::string(base_name)); }
487+
488+
template <class bit_vector=sdsl::bit_vector>
489+
inline auto add_wt_hutu_int(py::module& m, const std::string& base_name)
490+
{ return add_wt_hutu_int<bit_vector>(m, std::string(base_name)); }
491+
492+
template <class bit_vector=sdsl::bit_vector>
493+
inline auto add_wt_blcd(py::module& m, const std::string& base_name)
494+
{ return add_wt_blcd<bit_vector>(m, std::string(base_name)); }
495+
496+
template <class bit_vector=sdsl::bit_vector>
497+
inline auto add_wt_blcd_int(py::module& m, const std::string& base_name)
498+
{ return add_wt_blcd_int<bit_vector>(m, std::string(base_name)); }
499+
500+
397501
template <class bit_vector=sdsl::bit_vector>
398502
inline auto add_wt_int(py::module& m, const py::class_<bit_vector>& base)
399503
{
400504
auto base_name = py::cast<std::string>(base.attr("__name__"));
401-
402505
auto cls = add_wt_int<bit_vector>(m, base_name);
403-
404-
m.attr("wavelet_tree_int").attr("__setitem__")(base_name, cls);
405506
m.attr("wavelet_tree_int_by_base").attr("__setitem__")(base, cls);
507+
return cls;
508+
}
509+
510+
511+
template <class bit_vector=sdsl::bit_vector>
512+
inline auto add_wm_int(py::module& m, const py::class_<bit_vector>& base)
513+
{
514+
auto base_name = py::cast<std::string>(base.attr("__name__"));
515+
auto cls = add_wm_int<bit_vector>(m, base_name);
516+
m.attr("wavelet_matrix_int_by_base").attr("__setitem__")(base, cls);
517+
return cls;
518+
}
519+
520+
template <class bit_vector=sdsl::bit_vector>
521+
inline auto add_wt_huff(py::module& m, const py::class_<bit_vector>& base)
522+
{
523+
auto base_name = py::cast<std::string>(base.attr("__name__"));
524+
auto cls = add_wt_huff<bit_vector>(m, base_name);
525+
m.attr("wavelet_tree_huffman_by_base").attr("__setitem__")(base, cls);
526+
return cls;
527+
}
528+
529+
template <class bit_vector=sdsl::bit_vector>
530+
inline auto add_wt_huff_int(py::module& m, const py::class_<bit_vector>& base)
531+
{
532+
auto base_name = py::cast<std::string>(base.attr("__name__"));
533+
auto cls = add_wt_huff_int<bit_vector>(m, base_name);
534+
m.attr("wavelet_tree_huffman_int_by_base").attr("__setitem__")(base, cls);
535+
return cls;
536+
}
537+
538+
template <class bit_vector=sdsl::bit_vector>
539+
inline auto add_wt_hutu(py::module& m, const py::class_<bit_vector>& base)
540+
{
541+
auto base_name = py::cast<std::string>(base.attr("__name__"));
542+
auto cls = add_wt_hutu<bit_vector>(m, base_name);
543+
m.attr("wavelet_tree_hu_tucker_by_base").attr("__setitem__")(base, cls);
544+
return cls;
545+
}
406546

547+
template <class bit_vector=sdsl::bit_vector>
548+
inline auto add_wt_hutu_int(py::module& m, const py::class_<bit_vector>& base)
549+
{
550+
auto base_name = py::cast<std::string>(base.attr("__name__"));
551+
auto cls = add_wt_hutu_int<bit_vector>(m, base_name);
552+
m.attr("wavelet_tree_hu_tucker_int_by_base").attr("__setitem__")(base, cls);
553+
return cls;
554+
}
555+
556+
557+
template <class bit_vector=sdsl::bit_vector>
558+
inline auto add_wt_blcd(py::module& m, const py::class_<bit_vector>& base)
559+
{
560+
auto base_name = py::cast<std::string>(base.attr("__name__"));
561+
auto cls = add_wt_blcd<bit_vector>(m, base_name);
562+
m.attr("wavelet_tree_balanced_by_base").attr("__setitem__")(base, cls);
563+
return cls;
564+
}
565+
566+
template <class bit_vector=sdsl::bit_vector>
567+
inline auto add_wt_blcd_int(py::module& m, const py::class_<bit_vector>& base)
568+
{
569+
auto base_name = py::cast<std::string>(base.attr("__name__"));
570+
auto cls = add_wt_blcd_int<bit_vector>(m, base_name);
571+
m.attr("wavelet_tree_balanced_int_by_base").attr("__setitem__")(base, cls);
407572
return cls;
408573
}
409574

@@ -415,30 +580,70 @@ inline auto add_wavelet(py::module& m,
415580
m.attr("all_wavelet_trees") = py::list();
416581
m.attr("wavelet_tree_int") = py::dict();
417582
m.attr("wavelet_tree_int_by_base") = py::dict();
583+
m.attr("wavelet_matrix_int") = py::dict();
584+
m.attr("wavelet_matrix_int_by_base") = py::dict();
585+
m.attr("wavelet_tree_huffman") = py::dict();
586+
m.attr("wavelet_tree_huffman_by_base") = py::dict();
587+
m.attr("wavelet_tree_huffman_int") = py::dict();
588+
m.attr("wavelet_tree_huffman_int_by_base") = py::dict();
589+
m.attr("wavelet_tree_hu_tucker") = py::dict();
590+
m.attr("wavelet_tree_hu_tucker_by_base") = py::dict();
591+
m.attr("wavelet_tree_hu_tucker_int") = py::dict();
592+
m.attr("wavelet_tree_hu_tucker_int_by_base") = py::dict();
593+
m.attr("wavelet_tree_balanced") = py::dict();
594+
m.attr("wavelet_tree_balanced_by_base") = py::dict();
595+
m.attr("wavelet_tree_balanced_int") = py::dict();
596+
m.attr("wavelet_tree_balanced_int_by_base") = py::dict();
418597

419598
return std::make_tuple(
420599
add_wt_int<>(m, ""),
421600
add_wt_int(m, std::get<0>(t)),
422-
add_wt_int(m, std::get<3>(t)),
423-
//add_wt_int(m, std::get<5>(t)),
424-
add_wt_int(m, std::get<6>(t)),
425-
add_wt_int(m, std::get<8>(t)),
426-
add_wt_int(m, std::get<10>(t)),
427-
add_wavelet_class<sdsl::wm_int<>>(m, "WaveletMatrixInt", doc_wm_int),
428-
429-
add_wavelet_class<sdsl::wt_gmr_rs<>>(m, "WaveletTreeGMRrs",
601+
add_wt_int(m, std::get<1>(t)),
602+
add_wt_int(m, std::get<2>(t)),
603+
604+
add_wm_int<>(m, ""),
605+
add_wm_int(m, std::get<0>(t)),
606+
add_wm_int(m, std::get<1>(t)),
607+
add_wm_int(m, std::get<2>(t)),
608+
609+
add_wt_huff<>(m, ""),
610+
add_wt_huff(m, std::get<0>(t)),
611+
add_wt_huff(m, std::get<1>(t)),
612+
add_wt_huff(m, std::get<2>(t)),
613+
614+
add_wt_huff_int<>(m, ""),
615+
add_wt_huff_int(m, std::get<0>(t)),
616+
add_wt_huff_int(m, std::get<1>(t)),
617+
add_wt_huff_int(m, std::get<2>(t)),
618+
619+
add_wt_hutu<>(m, ""),
620+
add_wt_hutu(m, std::get<0>(t)),
621+
add_wt_hutu(m, std::get<1>(t)),
622+
add_wt_hutu(m, std::get<2>(t)),
623+
624+
add_wt_hutu_int<>(m, ""),
625+
add_wt_hutu_int(m, std::get<0>(t)),
626+
add_wt_hutu_int(m, std::get<1>(t)),
627+
add_wt_hutu_int(m, std::get<2>(t)),
628+
629+
add_wt_blcd<>(m, ""),
630+
add_wt_blcd(m, std::get<0>(t)),
631+
add_wt_blcd(m, std::get<1>(t)),
632+
add_wt_blcd(m, std::get<2>(t)),
633+
634+
add_wt_blcd_int<>(m, ""),
635+
add_wt_blcd_int(m, std::get<0>(t)),
636+
add_wt_blcd_int(m, std::get<1>(t)),
637+
add_wt_blcd_int(m, std::get<2>(t)),
638+
639+
add_wavelet_class<sdsl::wt_gmr_rs<>>(m, "WaveletTreeGMRrankselect",
430640
doc_wt_gmr_rs),
431-
add_wavelet_class<sdsl::wt_gmr<>>(m, "WaveletTreeGMR", doc_wt_gmr),
432-
add_wavelet_class<sdsl::wt_huff<>>(m, "WaveletTreeHuffman",
433-
doc_wt_huff),
434-
add_wavelet_class<sdsl::wt_huff_int<>>(m, "WaveletTreeHuffmanInt",
435-
doc_wt_huff),
436-
add_wavelet_class<sdsl::wt_blcd<>>(m, "WaveletTreeBlcd", doc_wt_blcd),
437-
add_wavelet_class<sdsl::wt_blcd_int<>>(m, "WaveletTreeBlcdInt",
438-
doc_wt_blcd),
439-
add_wavelet_class<sdsl::wt_hutu<>>(m, "WaveletTreeHuTucker",
440-
doc_wt_hutu),
441-
add_wavelet_class<sdsl::wt_hutu_int<>>(m, "WaveletTreeHuTuckerInt",
442-
doc_wt_hutu),
641+
add_wavelet_class<sdsl::wt_gmr_rs<sdsl::enc_vector<>>>(
642+
m, "WaveletTreeGMRrankselectEnc", doc_wt_gmr_rs),
643+
add_wavelet_class<sdsl::wt_gmr<>>(m, "WaveletTreeGolynskiMunroRao",
644+
doc_wt_gmr),
645+
add_wavelet_class<sdsl::wt_gmr<sdsl::enc_vector<>>>(
646+
m, "WaveletTreeGolynskiMunroRaoEnc", doc_wt_gmr),
647+
443648
add_wavelet_class<sdsl::wt_ap<>>(m, "WaveletTreeAP", doc_wt_ap));
444649
}

‎setup.py‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,11 @@ def build_extensions(self):
9090
libraries=['sdsl'],
9191
),
9292
Extension(
93-
'pysdsl/__init__',
93+
(
94+
'pysdsl/pysdsl'
95+
if sys.version_info.major == 2
96+
else 'pysdsl/__init__'
97+
),
9498
['pysdsl/__init__.cpp'],
9599
include_dirs=[
96100
# Path to pybind11 headers

0 commit comments

Comments
 (0)