From 38e8a0f4fa445b5794e54f897645bc8c04297f0a Mon Sep 17 00:00:00 2001 From: parham-k Date: Thu, 2 May 2024 20:03:27 -0700 Subject: [PATCH 1/5] Add seq setter to ntHash --- include/btllib/nthash_kmer.hpp | 22 +++++++++++++++++++++- include/btllib/nthash_seed.hpp | 25 ++++++++++++++++++++++++- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/include/btllib/nthash_kmer.hpp b/include/btllib/nthash_kmer.hpp index a12ae59d..c482cb3f 100644 --- a/include/btllib/nthash_kmer.hpp +++ b/include/btllib/nthash_kmer.hpp @@ -300,6 +300,26 @@ class NtHash NtHash(NtHash&&) = default; + /** + * Reset iterator on a new sequence. Useful for re-using NtHash objects. + * @param seq New sequence for hashing + */ + void set_seq(const std::string& seq, size_t pos = 0) + { + this->seq = seq.data(); + this->seq_len = seq.size(); + this->pos = pos; + this->initialized = false; + this->hash_arr.reset(new uint64_t[num_hashes]); + check_error(this->seq_len < k, + "NtHash: sequence length (" + std::to_string(this->seq_len) + + ") is smaller than k (" + std::to_string(k) + ")"); + check_error(pos > this->seq_len - k, + "NtHash: passed position (" + std::to_string(pos) + + ") is larger than sequence length (" + + std::to_string(this->seq_len) + ")"); + } + /** * Calculate the hash values of current k-mer and advance to the next k-mer. * NtHash advances one nucleotide at a time until it finds a k-mer with valid @@ -475,7 +495,7 @@ class NtHash private: const char* seq; - const size_t seq_len; + size_t seq_len; hashing_internals::NUM_HASHES_TYPE num_hashes; hashing_internals::K_TYPE k; size_t pos; diff --git a/include/btllib/nthash_seed.hpp b/include/btllib/nthash_seed.hpp index 721f1525..cd624558 100644 --- a/include/btllib/nthash_seed.hpp +++ b/include/btllib/nthash_seed.hpp @@ -650,6 +650,29 @@ class SeedNtHash SeedNtHash(SeedNtHash&&) = default; + /** + * Reset iterator on a new sequence. Useful for re-using NtHash objects. + * @param seq New sequence for hashing + */ + void set_seq(const std::string& seq, size_t pos = 0) + { + this->seq = seq.data(); + this->seq_len = seq.size(); + this->pos = pos; + this->initialized = false; + this->fwd_hash.reset(new uint64_t[blocks.size()]); + this->rev_hash.reset(new uint64_t[blocks.size()]); + this->hash_arr.reset(new uint64_t[blocks.size() * num_hashes_per_seed]); + check_error(this->seq_len < k, + "SeedNtHash: sequence length (" + + std::to_string(this->seq_len) + ") is smaller than k (" + + std::to_string(k) + ")"); + check_error(pos > this->seq_len - k, + "SeedNtHash: passed position (" + std::to_string(pos) + + ") is larger than sequence length (" + + std::to_string(this->seq_len) + ")"); + } + /** * Calculate the next hash value. Refer to \ref NtHash::roll() for more * information. @@ -869,7 +892,7 @@ class SeedNtHash private: const char* seq; - const size_t seq_len; + size_t seq_len; hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed; hashing_internals::K_TYPE k; size_t pos; From b77413effcad96fe413024b31855befdecacf837 Mon Sep 17 00:00:00 2001 From: parham-k Date: Thu, 2 May 2024 20:03:35 -0700 Subject: [PATCH 2/5] Add seq setting tests --- tests/nthash.cpp | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/tests/nthash.cpp b/tests/nthash.cpp index a2909166..7f157714 100644 --- a/tests/nthash.cpp +++ b/tests/nthash.cpp @@ -449,5 +449,48 @@ main() } } + { + PRINT_TEST_NAME("k-mer reset seq") + const std::string seq1 = "ATGCTAGTAGCTGAC"; + const std::string seq2 = "GTGACTAGCTGACTG"; + const unsigned h = 3, k = 7; + btllib::NtHash h1(seq1, h, k); + h1.roll(); + h1.roll(); + h1.roll(); + h1.set_seq(seq2); + btllib::NtHash h2(seq2, h, k); + bool can_roll = true; + while (can_roll) { + can_roll = h1.roll(); + can_roll |= h2.roll(); + TEST_ASSERT_ARRAY_EQ(h1.hashes(), h2.hashes(), h) + } + TEST_ASSERT(!h1.roll()) + TEST_ASSERT(!h2.roll()) + } + + { + PRINT_TEST_NAME("seed reset seq") + const std::string seq1 = "ATGCTAGTAGCTGAC"; + const std::string seq2 = "GTGACTAGCTGACTG"; + const std::vector seeds = { "11011" }; + const unsigned h = 3, k = seeds[0].size(); + btllib::SeedNtHash h1(seq1, seeds, h, k); + h1.roll(); + h1.roll(); + h1.roll(); + h1.set_seq(seq2); + btllib::SeedNtHash h2(seq2, seeds, h, k); + bool can_roll = true; + while (can_roll) { + can_roll = h1.roll(); + can_roll |= h2.roll(); + TEST_ASSERT_ARRAY_EQ(h1.hashes(), h2.hashes(), h) + } + TEST_ASSERT(!h1.roll()) + TEST_ASSERT(!h2.roll()) + } + return 0; } From a0a5ab89fa8210927153f488ca65b043298e9f4f Mon Sep 17 00:00:00 2001 From: parham-k Date: Thu, 2 May 2024 20:03:40 -0700 Subject: [PATCH 3/5] Bump version --- meson.build | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/meson.build b/meson.build index db8dfb77..cf988cfa 100644 --- a/meson.build +++ b/meson.build @@ -1,5 +1,5 @@ project('btllib', 'cpp', - version : '1.7.2', + version : '1.7.3', license : 'GPL3', default_options : [ 'cpp_std=c++17', 'warning_level=3', 'werror=true', 'b_coverage=true' ], meson_version : '>= 0.60.0') From 1024481b03a5d13998fdcd9c0cfee1fb643a52c4 Mon Sep 17 00:00:00 2001 From: parham-k Date: Thu, 2 May 2024 20:18:30 -0700 Subject: [PATCH 4/5] Update wrappers --- wrappers/python/btllib_wrap.cxx | 216 ++++++++++++++++++++++++++++++++ 1 file changed, 216 insertions(+) diff --git a/wrappers/python/btllib_wrap.cxx b/wrappers/python/btllib_wrap.cxx index 8d279b38..759ded5c 100644 --- a/wrappers/python/btllib_wrap.cxx +++ b/wrappers/python/btllib_wrap.cxx @@ -37375,6 +37375,113 @@ SWIGINTERN PyObject *_wrap_parse_seeds(PyObject *self, PyObject *args) { } +SWIGINTERN PyObject *_wrap_SeedNtHash_set_seq__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + btllib::SeedNtHash *arg1 = (btllib::SeedNtHash *) 0 ; + std::string *arg2 = 0 ; + size_t arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + size_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_btllib__SeedNtHash, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SeedNtHash_set_seq" "', argument " "1"" of type '" "btllib::SeedNtHash *""'"); + } + arg1 = reinterpret_cast< btllib::SeedNtHash * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SeedNtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SeedNtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SeedNtHash_set_seq" "', argument " "3"" of type '" "size_t""'"); + } + arg3 = static_cast< size_t >(val3); + (arg1)->set_seq((std::string const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SeedNtHash_set_seq__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + btllib::SeedNtHash *arg1 = (btllib::SeedNtHash *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_btllib__SeedNtHash, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SeedNtHash_set_seq" "', argument " "1"" of type '" "btllib::SeedNtHash *""'"); + } + arg1 = reinterpret_cast< btllib::SeedNtHash * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SeedNtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SeedNtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->set_seq((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SeedNtHash_set_seq(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + (void)self; + if (!(argc = SWIG_Python_UnpackTuple(args, "SeedNtHash_set_seq", 0, 3, argv+1))) SWIG_fail; + argv[0] = self; + if (argc == 2) { + PyObject *retobj = _wrap_SeedNtHash_set_seq__SWIG_1(self, argc, argv); + if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; + SWIG_fail; + } + if (argc == 3) { + PyObject *retobj = _wrap_SeedNtHash_set_seq__SWIG_0(self, argc, argv); + if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; + SWIG_fail; + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SeedNtHash_set_seq'.\n" + " Possible C/C++ prototypes are:\n" + " btllib::SeedNtHash::set_seq(std::string const &,size_t)\n" + " btllib::SeedNtHash::set_seq(std::string const &)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_SeedNtHash_roll(PyObject *self, PyObject *args) { PyObject *resultobj = 0; btllib::SeedNtHash *arg1 = (btllib::SeedNtHash *) 0 ; @@ -41633,6 +41740,113 @@ SWIGINTERN PyObject *_wrap_sub_hash(PyObject *self, PyObject *args) { } +SWIGINTERN PyObject *_wrap_NtHash_set_seq__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + btllib::NtHash *arg1 = (btllib::NtHash *) 0 ; + std::string *arg2 = 0 ; + size_t arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + size_t val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_btllib__NtHash, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NtHash_set_seq" "', argument " "1"" of type '" "btllib::NtHash *""'"); + } + arg1 = reinterpret_cast< btllib::NtHash * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NtHash_set_seq" "', argument " "3"" of type '" "size_t""'"); + } + arg3 = static_cast< size_t >(val3); + (arg1)->set_seq((std::string const &)*arg2,arg3); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NtHash_set_seq__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + btllib::NtHash *arg1 = (btllib::NtHash *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_btllib__NtHash, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NtHash_set_seq" "', argument " "1"" of type '" "btllib::NtHash *""'"); + } + arg1 = reinterpret_cast< btllib::NtHash * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NtHash_set_seq" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->set_seq((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NtHash_set_seq(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + (void)self; + if (!(argc = SWIG_Python_UnpackTuple(args, "NtHash_set_seq", 0, 3, argv+1))) SWIG_fail; + argv[0] = self; + if (argc == 2) { + PyObject *retobj = _wrap_NtHash_set_seq__SWIG_1(self, argc, argv); + if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; + SWIG_fail; + } + if (argc == 3) { + PyObject *retobj = _wrap_NtHash_set_seq__SWIG_0(self, argc, argv); + if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; + SWIG_fail; + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NtHash_set_seq'.\n" + " Possible C/C++ prototypes are:\n" + " btllib::NtHash::set_seq(std::string const &,size_t)\n" + " btllib::NtHash::set_seq(std::string const &)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_NtHash_roll(PyObject *self, PyObject *args) { PyObject *resultobj = 0; btllib::NtHash *arg1 = (btllib::NtHash *) 0 ; @@ -67165,6 +67379,7 @@ SwigPyBuiltin__btllib__SeedNtHash_richcompare(PyObject *self, PyObject *other, i } SWIGINTERN PyMethodDef SwigPyBuiltin__btllib__SeedNtHash_methods[] = { + { "set_seq", _wrap_SeedNtHash_set_seq, METH_VARARGS, "" }, { "roll", _wrap_SeedNtHash_roll, METH_NOARGS, "" }, { "roll_back", _wrap_SeedNtHash_roll_back, METH_NOARGS, "" }, { "peek", _wrap_SeedNtHash_peek, METH_VARARGS, "" }, @@ -67653,6 +67868,7 @@ SwigPyBuiltin__btllib__NtHash_richcompare(PyObject *self, PyObject *other, int o } SWIGINTERN PyMethodDef SwigPyBuiltin__btllib__NtHash_methods[] = { + { "set_seq", _wrap_NtHash_set_seq, METH_VARARGS, "" }, { "roll", _wrap_NtHash_roll, METH_NOARGS, "" }, { "roll_back", _wrap_NtHash_roll_back, METH_NOARGS, "" }, { "peek", _wrap_NtHash_peek, METH_VARARGS, "" }, From fa07066b3943ace283b3f4337bef498ea1b86f30 Mon Sep 17 00:00:00 2001 From: parham-k Date: Thu, 2 May 2024 20:18:46 -0700 Subject: [PATCH 5/5] Update docs --- docs/classbtllib_1_1NtHash-members.html | 3 +- docs/classbtllib_1_1NtHash.html | 43 + docs/classbtllib_1_1SeedNtHash-members.html | 1 + docs/classbtllib_1_1SeedNtHash.html | 43 + ...unting__bloom__filter-inl_8hpp_source.html | 4 +- docs/functions_0x73.html | 6 +- docs/functions_func_0x73.html | 6 +- docs/nthash__kmer_8hpp_source.html | 535 +++++++------ docs/nthash__seed_8hpp_source.html | 744 +++++++++--------- docs/search/all_73.js | 1 + docs/search/functions_73.js | 1 + 11 files changed, 761 insertions(+), 626 deletions(-) diff --git a/docs/classbtllib_1_1NtHash-members.html b/docs/classbtllib_1_1NtHash-members.html index 72293e12..5d9a9b34 100644 --- a/docs/classbtllib_1_1NtHash-members.html +++ b/docs/classbtllib_1_1NtHash-members.html @@ -109,7 +109,8 @@ peek_back(char char_in)btllib::NtHashinline roll()btllib::NtHashinline roll_back()btllib::NtHashinline - sub(const std::vector< unsigned > &positions, const std::vector< unsigned char > &new_bases) (defined in btllib::NtHash)btllib::NtHashinline + set_seq(const std::string &seq, size_t pos=0)btllib::NtHashinline + sub(const std::vector< unsigned > &positions, const std::vector< unsigned char > &new_bases) (defined in btllib::NtHash)btllib::NtHashinline
diff --git a/docs/classbtllib_1_1NtHash.html b/docs/classbtllib_1_1NtHash.html index 33215f69..2e939ed1 100644 --- a/docs/classbtllib_1_1NtHash.html +++ b/docs/classbtllib_1_1NtHash.html @@ -108,6 +108,8 @@  NtHash (NtHash &&)=default   +void set_seq (const std::string &seq, size_t pos=0) +  bool roll ()   bool roll_back () @@ -559,6 +561,47 @@

Member Function Documentation

Like the roll() function, but advance backwards.

Returns
true on success and false otherwise
+ + + +
+
+ + + + + +
+ + + + + + + + + + + + + + + + + + +
void btllib::NtHash::set_seq (const std::string & seq,
size_t pos = 0 
)
+ 		+inline
+
+

Reset iterator on a new sequence. Useful for re-using NtHash objects.

+
Parameters
+ + +
seqNew sequence for hashing
+
+
+
The documentation for this class was generated from the following file:
    diff --git a/docs/classbtllib_1_1SeedNtHash-members.html b/docs/classbtllib_1_1SeedNtHash-members.html index 80e10afa..09acc8e3 100644 --- a/docs/classbtllib_1_1SeedNtHash-members.html +++ b/docs/classbtllib_1_1SeedNtHash-members.html @@ -112,6 +112,7 @@ SeedNtHash(const std::string &seq, const std::vector< std::vector< unsigned >> &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, size_t pos=0)btllib::SeedNtHashinline SeedNtHash(const SeedNtHash &obj) (defined in btllib::SeedNtHash)btllib::SeedNtHashinline SeedNtHash(SeedNtHash &&)=default (defined in btllib::SeedNtHash)btllib::SeedNtHash + set_seq(const std::string &seq, size_t pos=0)btllib::SeedNtHashinline
    diff --git a/docs/classbtllib_1_1SeedNtHash.html b/docs/classbtllib_1_1SeedNtHash.html index 4f90c90b..4d0649d6 100644 --- a/docs/classbtllib_1_1SeedNtHash.html +++ b/docs/classbtllib_1_1SeedNtHash.html @@ -112,6 +112,8 @@  SeedNtHash (SeedNtHash &&)=default   +void set_seq (const std::string &seq, size_t pos=0) +  bool roll ()   bool roll_back () @@ -734,6 +736,47 @@

    Member Function Documentation

    Like the roll() function, but advance backwards.

    Returns
    true on success and false otherwise.
    + + + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    void btllib::SeedNtHash::set_seq (const std::string & seq,
    size_t pos = 0 
    )
    +     		+inline
    +
    +

    Reset iterator on a new sequence. Useful for re-using NtHash objects.

    +
    Parameters
    + + +
    seqNew sequence for hashing
    +
    +
    +
    The documentation for this class was generated from the following file:
      diff --git a/docs/counting__bloom__filter-inl_8hpp_source.html b/docs/counting__bloom__filter-inl_8hpp_source.html index 521e89ff..984f671d 100644 --- a/docs/counting__bloom__filter-inl_8hpp_source.html +++ b/docs/counting__bloom__filter-inl_8hpp_source.html @@ -517,7 +517,7 @@
      btllib::CountingBloomFilter
      Definition: counting_bloom_filter.hpp:42
      btllib::check_warning
      void check_warning(bool condition, const std::string &msg)
      btllib::KmerCountingBloomFilter::clear
      void clear(const char *seq, size_t seq_len)
      Definition: counting_bloom_filter-inl.hpp:289
      -
      btllib::NtHash::hashes
      const uint64_t * hashes() const
      Definition: nthash_kmer.hpp:443
      +
      btllib::NtHash::hashes
      const uint64_t * hashes() const
      Definition: nthash_kmer.hpp:463
      btllib::CountingBloomFilter::remove
      void remove(const uint64_t *hashes)
      Definition: counting_bloom_filter-inl.hpp:89
      btllib::KmerCountingBloomFilter::contains_insert_thresh
      T contains_insert_thresh(const char *seq, size_t seq_len, T threshold)
      Definition: counting_bloom_filter-inl.hpp:350
      btllib::NtHash
      Definition: nthash_kmer.hpp:236
      @@ -531,7 +531,7 @@
      btllib::CountingBloomFilter::get_pop_cnt
      uint64_t get_pop_cnt(T threshold=1) const
      Definition: counting_bloom_filter-inl.hpp:167
      btllib::KmerCountingBloomFilter::contains_insert
      T contains_insert(const char *seq, size_t seq_len)
      Definition: counting_bloom_filter-inl.hpp:311
      btllib::CountingBloomFilter::get_occupancy
      double get_occupancy(T threshold=1) const
      Definition: counting_bloom_filter-inl.hpp:184
      -
      btllib::NtHash::roll
      bool roll()
      Definition: nthash_kmer.hpp:315
      +
      btllib::NtHash::roll
      bool roll()
      Definition: nthash_kmer.hpp:335
      btllib::KmerCountingBloomFilter::insert_thresh_contains
      T insert_thresh_contains(const char *seq, size_t seq_len, T threshold)
      Definition: counting_bloom_filter-inl.hpp:335
      btllib::CountingBloomFilter::insert_contains
      T insert_contains(const uint64_t *hashes, T n=1)
      Definition: counting_bloom_filter-inl.hpp:130
      btllib::KmerCountingBloomFilter::insert
      void insert(const char *seq, size_t seq_len)
      Definition: counting_bloom_filter-inl.hpp:269
      diff --git a/docs/functions_0x73.html b/docs/functions_0x73.html index 0b8ad102..ea885912 100644 --- a/docs/functions_0x73.html +++ b/docs/functions_0x73.html @@ -126,7 +126,7 @@

      - s -

        : btllib::SeedBloomFilter
      • SeedNtHash() -: btllib::SeedNtHash +: btllib::SeedNtHash
      • SEQ : btllib::Indexlr::Flag @@ -140,6 +140,10 @@

        - s -

        • set_seed() : btllib::RandSeq
          • +
        • set_seq() +: btllib::NtHash +, btllib::SeedNtHash +
        • SHORT_MODE : btllib::SeqReader::Flag , btllib::Indexlr::Flag diff --git a/docs/functions_func_0x73.html b/docs/functions_func_0x73.html index 7af9bc6f..b81c294a 100644 --- a/docs/functions_func_0x73.html +++ b/docs/functions_func_0x73.html @@ -122,7 +122,7 @@

          - s -

            : btllib::SeedBloomFilter
          • SeedNtHash() -: btllib::SeedNtHash +: btllib::SeedNtHash
          • SeqReader() : btllib::SeqReader @@ -133,6 +133,10 @@

            - s -

            diff --git a/docs/nthash__kmer_8hpp_source.html b/docs/nthash__kmer_8hpp_source.html index 15ae2398..c1f9abac 100644 --- a/docs/nthash__kmer_8hpp_source.html +++ b/docs/nthash__kmer_8hpp_source.html @@ -310,271 +310,288 @@
            300 
            301  NtHash(NtHash&&) = default;
            302 
            -
            315  bool roll()
            -
            316  {
            -
            317  if (!initialized) {
            -
            318  return init();
            -
            319  }
            -
            320  if (pos >= seq_len - k) {
            -
            321  return false;
            -
            322  }
            -
            323  if (hashing_internals::SEED_TAB[(unsigned char)seq[pos + k]] ==
            -
            324  hashing_internals::SEED_N) {
            -
            325  pos += k;
            -
            326  return init();
            -
            327  }
            -
            328  fwd_hash = next_forward_hash(fwd_hash, k, seq[pos], seq[pos + k]);
            -
            329  rev_hash = next_reverse_hash(rev_hash, k, seq[pos], seq[pos + k]);
            -
            330  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            -
            331  ++pos;
            -
            332  return true;
            -
            333  }
            -
            334 
            -
            339  bool roll_back()
            -
            340  {
            -
            341  if (!initialized) {
            -
            342  return init();
            -
            343  }
            -
            344  if (pos == 0) {
            -
            345  return false;
            -
            346  }
            -
            347  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N && pos >= k) {
            -
            348  pos -= k;
            -
            349  return init();
            -
            350  }
            -
            351  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N) {
            -
            352  return false;
            -
            353  }
            -
            354  fwd_hash = prev_forward_hash(fwd_hash, k, seq[pos + k - 1], seq[pos - 1]);
            -
            355  rev_hash = prev_reverse_hash(rev_hash, k, seq[pos + k - 1], seq[pos - 1]);
            -
            356  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            -
            357  --pos;
            -
            358  return true;
            -
            359  }
            -
            360 
            -
            367  bool peek()
            -
            368  {
            -
            369  if (pos >= seq_len - k) {
            -
            370  return false;
            -
            371  }
            -
            372  return peek(seq[pos + k]);
            -
            373  }
            -
            374 
            -
            379  bool peek_back()
            -
            380  {
            -
            381  if (pos == 0) {
            -
            382  return false;
            -
            383  }
            -
            384  return peek_back(seq[pos - 1]);
            -
            385  }
            -
            386 
            -
            393  bool peek(char char_in)
            -
            394  {
            -
            395  if (!initialized) {
            -
            396  return init();
            -
            397  }
            -
            398  if (SEED_TAB[(unsigned char)char_in] == SEED_N) {
            -
            399  return false;
            -
            400  }
            -
            401  const uint64_t fwd = next_forward_hash(fwd_hash, k, seq[pos], char_in);
            -
            402  const uint64_t rev = next_reverse_hash(rev_hash, k, seq[pos], char_in);
            -
            403  extend_hashes(fwd, rev, k, num_hashes, hash_arr.get());
            -
            404  return true;
            +
            307  void set_seq(const std::string& seq, size_t pos = 0)
            +
            308  {
            +
            309  this->seq = seq.data();
            +
            310  this->seq_len = seq.size();
            +
            311  this->pos = pos;
            +
            312  this->initialized = false;
            +
            313  this->hash_arr.reset(new uint64_t[num_hashes]);
            +
            314  check_error(this->seq_len < k,
            +
            315  "NtHash: sequence length (" + std::to_string(this->seq_len) +
            +
            316  ") is smaller than k (" + std::to_string(k) + ")");
            +
            317  check_error(pos > this->seq_len - k,
            +
            318  "NtHash: passed position (" + std::to_string(pos) +
            +
            319  ") is larger than sequence length (" +
            +
            320  std::to_string(this->seq_len) + ")");
            +
            321  }
            +
            322 
            +
            335  bool roll()
            +
            336  {
            +
            337  if (!initialized) {
            +
            338  return init();
            +
            339  }
            +
            340  if (pos >= seq_len - k) {
            +
            341  return false;
            +
            342  }
            +
            343  if (hashing_internals::SEED_TAB[(unsigned char)seq[pos + k]] ==
            +
            344  hashing_internals::SEED_N) {
            +
            345  pos += k;
            +
            346  return init();
            +
            347  }
            +
            348  fwd_hash = next_forward_hash(fwd_hash, k, seq[pos], seq[pos + k]);
            +
            349  rev_hash = next_reverse_hash(rev_hash, k, seq[pos], seq[pos + k]);
            +
            350  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            +
            351  ++pos;
            +
            352  return true;
            +
            353  }
            +
            354 
            +
            359  bool roll_back()
            +
            360  {
            +
            361  if (!initialized) {
            +
            362  return init();
            +
            363  }
            +
            364  if (pos == 0) {
            +
            365  return false;
            +
            366  }
            +
            367  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N && pos >= k) {
            +
            368  pos -= k;
            +
            369  return init();
            +
            370  }
            +
            371  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N) {
            +
            372  return false;
            +
            373  }
            +
            374  fwd_hash = prev_forward_hash(fwd_hash, k, seq[pos + k - 1], seq[pos - 1]);
            +
            375  rev_hash = prev_reverse_hash(rev_hash, k, seq[pos + k - 1], seq[pos - 1]);
            +
            376  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            +
            377  --pos;
            +
            378  return true;
            +
            379  }
            +
            380 
            +
            387  bool peek()
            +
            388  {
            +
            389  if (pos >= seq_len - k) {
            +
            390  return false;
            +
            391  }
            +
            392  return peek(seq[pos + k]);
            +
            393  }
            +
            394 
            +
            399  bool peek_back()
            +
            400  {
            +
            401  if (pos == 0) {
            +
            402  return false;
            +
            403  }
            +
            404  return peek_back(seq[pos - 1]);
            405  }
            406 
            -
            411  bool peek_back(char char_in)
            -
            412  {
            -
            413  if (!initialized) {
            -
            414  return init();
            -
            415  }
            -
            416  if (SEED_TAB[(unsigned char)char_in] == SEED_N) {
            -
            417  return false;
            -
            418  }
            -
            419  const unsigned char char_out = seq[pos + k - 1];
            -
            420  const uint64_t fwd = prev_forward_hash(fwd_hash, k, char_out, char_in);
            -
            421  const uint64_t rev = prev_reverse_hash(rev_hash, k, char_out, char_in);
            -
            422  extend_hashes(fwd, rev, k, num_hashes, hash_arr.get());
            -
            423  return true;
            -
            424  }
            -
            425 
            -
            426  void sub(const std::vector<unsigned>& positions,
            -
            427  const std::vector<unsigned char>& new_bases)
            -
            428  {
            -
            429  sub_hash(fwd_hash,
            -
            430  rev_hash,
            -
            431  seq + pos,
            -
            432  positions,
            -
            433  new_bases,
            -
            434  get_k(),
            -
            435  get_hash_num(),
            -
            436  hash_arr.get());
            -
            437  }
            -
            438 
            -
            443  const uint64_t* hashes() const { return hash_arr.get(); }
            -
            444 
            -
            450  size_t get_pos() const { return pos; }
            -
            451 
            -
            456  hashing_internals::NUM_HASHES_TYPE get_hash_num() const { return num_hashes; }
            -
            457 
            -
            462  hashing_internals::K_TYPE get_k() const { return k; }
            -
            463 
            -
            468  uint64_t get_forward_hash() const { return fwd_hash; }
            -
            469 
            -
            474  uint64_t get_reverse_hash() const { return rev_hash; }
            -
            475 
            -
            476 private:
            -
            477  const char* seq;
            -
            478  const size_t seq_len;
            -
            479  hashing_internals::NUM_HASHES_TYPE num_hashes;
            -
            480  hashing_internals::K_TYPE k;
            -
            481  size_t pos;
            -
            482  bool initialized;
            -
            483  uint64_t fwd_hash = 0;
            -
            484  uint64_t rev_hash = 0;
            -
            485  std::unique_ptr<uint64_t[]> hash_arr;
            -
            486 
            -
            491  bool init()
            -
            492  {
            -
            493  bool has_n = true;
            -
            494  while (pos <= seq_len - k + 1 && has_n) {
            -
            495  has_n = false;
            -
            496  for (unsigned i = 0; i < k && pos <= seq_len - k + 1; i++) {
            -
            497  if (SEED_TAB[(unsigned char)seq[pos + k - i - 1]] == SEED_N) {
            -
            498  pos += k - i;
            -
            499  has_n = true;
            -
            500  }
            -
            501  }
            -
            502  }
            -
            503  if (pos > seq_len - k) {
            -
            504  return false;
            -
            505  }
            -
            506  fwd_hash = base_forward_hash(seq + pos, k);
            -
            507  rev_hash = base_reverse_hash(seq + pos, k);
            -
            508  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            -
            509  initialized = true;
            -
            510  return true;
            -
            511  }
            -
            512 };
            -
            513 
            -
            520 class BlindNtHash
            -
            521 {
            -
            522 
            -
            523 public:
            -
            532  BlindNtHash(const std::string& seq,
            -
            533  hashing_internals::NUM_HASHES_TYPE num_hashes,
            -
            534  hashing_internals::K_TYPE k,
            -
            535  long pos = 0)
            -
            536  : seq(seq.data() + pos, seq.data() + pos + k)
            -
            537  , num_hashes(num_hashes)
            -
            538  , pos(pos)
            -
            539  , fwd_hash(base_forward_hash(seq.data(), k))
            -
            540  , rev_hash(base_reverse_hash(seq.data(), k))
            -
            541  , hash_arr(new uint64_t[num_hashes])
            -
            542  {
            -
            543  check_error(k == 0, "BlindNtHash: k must be greater than 0");
            -
            544  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            -
            545  }
            -
            546 
            -
            547  BlindNtHash(const BlindNtHash& obj)
            -
            548  : seq(obj.seq)
            -
            549  , num_hashes(obj.num_hashes)
            -
            550  , pos(obj.pos)
            -
            551  , fwd_hash(obj.fwd_hash)
            -
            552  , rev_hash(obj.rev_hash)
            -
            553  , hash_arr(new uint64_t[obj.num_hashes])
            -
            554  {
            -
            555  std::memcpy(
            -
            556  hash_arr.get(), obj.hash_arr.get(), num_hashes * sizeof(uint64_t));
            -
            557  }
            -
            558 
            -
            559  BlindNtHash(BlindNtHash&&) = default;
            -
            560 
            -
            567  void roll(char char_in)
            -
            568  {
            -
            569  fwd_hash = next_forward_hash(fwd_hash, seq.size(), seq.front(), char_in);
            -
            570  rev_hash = next_reverse_hash(rev_hash, seq.size(), seq.front(), char_in);
            -
            571  extend_hashes(fwd_hash, rev_hash, seq.size(), num_hashes, hash_arr.get());
            -
            572  seq.pop_front();
            -
            573  seq.push_back(char_in);
            -
            574  ++pos;
            -
            575  }
            -
            576 
            -
            580  void roll_back(char char_in)
            -
            581  {
            -
            582  fwd_hash = prev_forward_hash(fwd_hash, seq.size(), seq.back(), char_in);
            -
            583  rev_hash = prev_reverse_hash(rev_hash, seq.size(), seq.back(), char_in);
            -
            584  extend_hashes(fwd_hash, rev_hash, seq.size(), num_hashes, hash_arr.get());
            -
            585  seq.pop_back();
            -
            586  seq.push_front(char_in);
            -
            587  --pos;
            -
            588  }
            -
            589 
            -
            593  void peek(char char_in)
            -
            594  {
            -
            595  const hashing_internals::K_TYPE k = seq.size();
            -
            596  const uint64_t fwd = next_forward_hash(fwd_hash, k, seq.front(), char_in);
            -
            597  const uint64_t rev = next_reverse_hash(rev_hash, k, seq.front(), char_in);
            -
            598  extend_hashes(fwd, rev, seq.size(), num_hashes, hash_arr.get());
            -
            599  }
            -
            600 
            -
            604  void peek_back(char char_in)
            -
            605  {
            -
            606  const hashing_internals::K_TYPE k = seq.size();
            -
            607  const uint64_t fwd = prev_forward_hash(fwd_hash, k, seq.back(), char_in);
            -
            608  const uint64_t rev = prev_reverse_hash(rev_hash, k, seq.back(), char_in);
            -
            609  extend_hashes(fwd, rev, seq.size(), num_hashes, hash_arr.get());
            -
            610  }
            -
            611 
            -
            616  const uint64_t* hashes() const { return hash_arr.get(); }
            -
            617 
            -
            623  long get_pos() const { return pos; }
            -
            624 
            -
            629  hashing_internals::NUM_HASHES_TYPE get_hash_num() const { return num_hashes; }
            -
            630 
            -
            635  hashing_internals::K_TYPE get_k() const { return seq.size(); }
            -
            636 
            -
            641  uint64_t get_forward_hash() const { return fwd_hash; }
            -
            642 
            -
            647  uint64_t get_reverse_hash() const { return rev_hash; }
            -
            648 
            -
            649 private:
            -
            650  std::deque<char> seq;
            -
            651  hashing_internals::NUM_HASHES_TYPE num_hashes;
            -
            652  long pos;
            -
            653  uint64_t fwd_hash;
            -
            654  uint64_t rev_hash;
            -
            655  std::unique_ptr<uint64_t[]> hash_arr;
            -
            656 };
            -
            657 
            -
            658 } // namespace btllib
            -
            btllib::BlindNtHash::peek_back
            void peek_back(char char_in)
            Definition: nthash_kmer.hpp:604
            -
            btllib::NtHash::peek
            bool peek()
            Definition: nthash_kmer.hpp:367
            -
            btllib::NtHash::get_reverse_hash
            uint64_t get_reverse_hash() const
            Definition: nthash_kmer.hpp:474
            -
            btllib::NtHash::peek
            bool peek(char char_in)
            Definition: nthash_kmer.hpp:393
            -
            btllib::BlindNtHash::get_pos
            long get_pos() const
            Definition: nthash_kmer.hpp:623
            -
            btllib::NtHash::peek_back
            bool peek_back(char char_in)
            Definition: nthash_kmer.hpp:411
            +
            413  bool peek(char char_in)
            +
            414  {
            +
            415  if (!initialized) {
            +
            416  return init();
            +
            417  }
            +
            418  if (SEED_TAB[(unsigned char)char_in] == SEED_N) {
            +
            419  return false;
            +
            420  }
            +
            421  const uint64_t fwd = next_forward_hash(fwd_hash, k, seq[pos], char_in);
            +
            422  const uint64_t rev = next_reverse_hash(rev_hash, k, seq[pos], char_in);
            +
            423  extend_hashes(fwd, rev, k, num_hashes, hash_arr.get());
            +
            424  return true;
            +
            425  }
            +
            426 
            +
            431  bool peek_back(char char_in)
            +
            432  {
            +
            433  if (!initialized) {
            +
            434  return init();
            +
            435  }
            +
            436  if (SEED_TAB[(unsigned char)char_in] == SEED_N) {
            +
            437  return false;
            +
            438  }
            +
            439  const unsigned char char_out = seq[pos + k - 1];
            +
            440  const uint64_t fwd = prev_forward_hash(fwd_hash, k, char_out, char_in);
            +
            441  const uint64_t rev = prev_reverse_hash(rev_hash, k, char_out, char_in);
            +
            442  extend_hashes(fwd, rev, k, num_hashes, hash_arr.get());
            +
            443  return true;
            +
            444  }
            +
            445 
            +
            446  void sub(const std::vector<unsigned>& positions,
            +
            447  const std::vector<unsigned char>& new_bases)
            +
            448  {
            +
            449  sub_hash(fwd_hash,
            +
            450  rev_hash,
            +
            451  seq + pos,
            +
            452  positions,
            +
            453  new_bases,
            +
            454  get_k(),
            +
            455  get_hash_num(),
            +
            456  hash_arr.get());
            +
            457  }
            +
            458 
            +
            463  const uint64_t* hashes() const { return hash_arr.get(); }
            +
            464 
            +
            470  size_t get_pos() const { return pos; }
            +
            471 
            +
            476  hashing_internals::NUM_HASHES_TYPE get_hash_num() const { return num_hashes; }
            +
            477 
            +
            482  hashing_internals::K_TYPE get_k() const { return k; }
            +
            483 
            +
            488  uint64_t get_forward_hash() const { return fwd_hash; }
            +
            489 
            +
            494  uint64_t get_reverse_hash() const { return rev_hash; }
            +
            495 
            +
            496 private:
            +
            497  const char* seq;
            +
            498  size_t seq_len;
            +
            499  hashing_internals::NUM_HASHES_TYPE num_hashes;
            +
            500  hashing_internals::K_TYPE k;
            +
            501  size_t pos;
            +
            502  bool initialized;
            +
            503  uint64_t fwd_hash = 0;
            +
            504  uint64_t rev_hash = 0;
            +
            505  std::unique_ptr<uint64_t[]> hash_arr;
            +
            506 
            +
            511  bool init()
            +
            512  {
            +
            513  bool has_n = true;
            +
            514  while (pos <= seq_len - k + 1 && has_n) {
            +
            515  has_n = false;
            +
            516  for (unsigned i = 0; i < k && pos <= seq_len - k + 1; i++) {
            +
            517  if (SEED_TAB[(unsigned char)seq[pos + k - i - 1]] == SEED_N) {
            +
            518  pos += k - i;
            +
            519  has_n = true;
            +
            520  }
            +
            521  }
            +
            522  }
            +
            523  if (pos > seq_len - k) {
            +
            524  return false;
            +
            525  }
            +
            526  fwd_hash = base_forward_hash(seq + pos, k);
            +
            527  rev_hash = base_reverse_hash(seq + pos, k);
            +
            528  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            +
            529  initialized = true;
            +
            530  return true;
            +
            531  }
            +
            532 };
            +
            533 
            +
            540 class BlindNtHash
            +
            541 {
            +
            542 
            +
            543 public:
            +
            552  BlindNtHash(const std::string& seq,
            +
            553  hashing_internals::NUM_HASHES_TYPE num_hashes,
            +
            554  hashing_internals::K_TYPE k,
            +
            555  long pos = 0)
            +
            556  : seq(seq.data() + pos, seq.data() + pos + k)
            +
            557  , num_hashes(num_hashes)
            +
            558  , pos(pos)
            +
            559  , fwd_hash(base_forward_hash(seq.data(), k))
            +
            560  , rev_hash(base_reverse_hash(seq.data(), k))
            +
            561  , hash_arr(new uint64_t[num_hashes])
            +
            562  {
            +
            563  check_error(k == 0, "BlindNtHash: k must be greater than 0");
            +
            564  extend_hashes(fwd_hash, rev_hash, k, num_hashes, hash_arr.get());
            +
            565  }
            +
            566 
            +
            567  BlindNtHash(const BlindNtHash& obj)
            +
            568  : seq(obj.seq)
            +
            569  , num_hashes(obj.num_hashes)
            +
            570  , pos(obj.pos)
            +
            571  , fwd_hash(obj.fwd_hash)
            +
            572  , rev_hash(obj.rev_hash)
            +
            573  , hash_arr(new uint64_t[obj.num_hashes])
            +
            574  {
            +
            575  std::memcpy(
            +
            576  hash_arr.get(), obj.hash_arr.get(), num_hashes * sizeof(uint64_t));
            +
            577  }
            +
            578 
            +
            579  BlindNtHash(BlindNtHash&&) = default;
            +
            580 
            +
            587  void roll(char char_in)
            +
            588  {
            +
            589  fwd_hash = next_forward_hash(fwd_hash, seq.size(), seq.front(), char_in);
            +
            590  rev_hash = next_reverse_hash(rev_hash, seq.size(), seq.front(), char_in);
            +
            591  extend_hashes(fwd_hash, rev_hash, seq.size(), num_hashes, hash_arr.get());
            +
            592  seq.pop_front();
            +
            593  seq.push_back(char_in);
            +
            594  ++pos;
            +
            595  }
            +
            596 
            +
            600  void roll_back(char char_in)
            +
            601  {
            +
            602  fwd_hash = prev_forward_hash(fwd_hash, seq.size(), seq.back(), char_in);
            +
            603  rev_hash = prev_reverse_hash(rev_hash, seq.size(), seq.back(), char_in);
            +
            604  extend_hashes(fwd_hash, rev_hash, seq.size(), num_hashes, hash_arr.get());
            +
            605  seq.pop_back();
            +
            606  seq.push_front(char_in);
            +
            607  --pos;
            +
            608  }
            +
            609 
            +
            613  void peek(char char_in)
            +
            614  {
            +
            615  const hashing_internals::K_TYPE k = seq.size();
            +
            616  const uint64_t fwd = next_forward_hash(fwd_hash, k, seq.front(), char_in);
            +
            617  const uint64_t rev = next_reverse_hash(rev_hash, k, seq.front(), char_in);
            +
            618  extend_hashes(fwd, rev, seq.size(), num_hashes, hash_arr.get());
            +
            619  }
            +
            620 
            +
            624  void peek_back(char char_in)
            +
            625  {
            +
            626  const hashing_internals::K_TYPE k = seq.size();
            +
            627  const uint64_t fwd = prev_forward_hash(fwd_hash, k, seq.back(), char_in);
            +
            628  const uint64_t rev = prev_reverse_hash(rev_hash, k, seq.back(), char_in);
            +
            629  extend_hashes(fwd, rev, seq.size(), num_hashes, hash_arr.get());
            +
            630  }
            +
            631 
            +
            636  const uint64_t* hashes() const { return hash_arr.get(); }
            +
            637 
            +
            643  long get_pos() const { return pos; }
            +
            644 
            +
            649  hashing_internals::NUM_HASHES_TYPE get_hash_num() const { return num_hashes; }
            +
            650 
            +
            655  hashing_internals::K_TYPE get_k() const { return seq.size(); }
            +
            656 
            +
            661  uint64_t get_forward_hash() const { return fwd_hash; }
            +
            662 
            +
            667  uint64_t get_reverse_hash() const { return rev_hash; }
            +
            668 
            +
            669 private:
            +
            670  std::deque<char> seq;
            +
            671  hashing_internals::NUM_HASHES_TYPE num_hashes;
            +
            672  long pos;
            +
            673  uint64_t fwd_hash;
            +
            674  uint64_t rev_hash;
            +
            675  std::unique_ptr<uint64_t[]> hash_arr;
            +
            676 };
            +
            677 
            +
            678 } // namespace btllib
            +
            btllib::BlindNtHash::peek_back
            void peek_back(char char_in)
            Definition: nthash_kmer.hpp:624
            +
            btllib::NtHash::peek
            bool peek()
            Definition: nthash_kmer.hpp:387
            +
            btllib::NtHash::get_reverse_hash
            uint64_t get_reverse_hash() const
            Definition: nthash_kmer.hpp:494
            +
            btllib::NtHash::peek
            bool peek(char char_in)
            Definition: nthash_kmer.hpp:413
            +
            btllib::BlindNtHash::get_pos
            long get_pos() const
            Definition: nthash_kmer.hpp:643
            +
            btllib::NtHash::peek_back
            bool peek_back(char char_in)
            Definition: nthash_kmer.hpp:431
            btllib::NtHash::NtHash
            NtHash(const char *seq, size_t seq_len, hashing_internals::NUM_HASHES_TYPE num_hashes, hashing_internals::K_TYPE k, size_t pos=0)
            Definition: nthash_kmer.hpp:248
            -
            btllib::NtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_kmer.hpp:443
            -
            btllib::NtHash::get_forward_hash
            uint64_t get_forward_hash() const
            Definition: nthash_kmer.hpp:468
            +
            btllib::NtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_kmer.hpp:463
            +
            btllib::NtHash::get_forward_hash
            uint64_t get_forward_hash() const
            Definition: nthash_kmer.hpp:488
            btllib::NtHash
            Definition: nthash_kmer.hpp:236
            -
            btllib::NtHash::get_pos
            size_t get_pos() const
            Definition: nthash_kmer.hpp:450
            -
            btllib::NtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_kmer.hpp:462
            -
            btllib::BlindNtHash::BlindNtHash
            BlindNtHash(const std::string &seq, hashing_internals::NUM_HASHES_TYPE num_hashes, hashing_internals::K_TYPE k, long pos=0)
            Definition: nthash_kmer.hpp:532
            -
            btllib::BlindNtHash::get_forward_hash
            uint64_t get_forward_hash() const
            Definition: nthash_kmer.hpp:641
            -
            btllib::BlindNtHash
            Definition: nthash_kmer.hpp:520
            +
            btllib::NtHash::get_pos
            size_t get_pos() const
            Definition: nthash_kmer.hpp:470
            +
            btllib::NtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_kmer.hpp:482
            +
            btllib::BlindNtHash::BlindNtHash
            BlindNtHash(const std::string &seq, hashing_internals::NUM_HASHES_TYPE num_hashes, hashing_internals::K_TYPE k, long pos=0)
            Definition: nthash_kmer.hpp:552
            +
            btllib::NtHash::set_seq
            void set_seq(const std::string &seq, size_t pos=0)
            Definition: nthash_kmer.hpp:307
            +
            btllib::BlindNtHash::get_forward_hash
            uint64_t get_forward_hash() const
            Definition: nthash_kmer.hpp:661
            +
            btllib::BlindNtHash
            Definition: nthash_kmer.hpp:540
            btllib::check_error
            void check_error(bool condition, const std::string &msg)
            -
            btllib::NtHash::peek_back
            bool peek_back()
            Definition: nthash_kmer.hpp:379
            -
            btllib::BlindNtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_kmer.hpp:635
            -
            btllib::NtHash::roll
            bool roll()
            Definition: nthash_kmer.hpp:315
            +
            btllib::NtHash::peek_back
            bool peek_back()
            Definition: nthash_kmer.hpp:399
            +
            btllib::BlindNtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_kmer.hpp:655
            +
            btllib::NtHash::roll
            bool roll()
            Definition: nthash_kmer.hpp:335
            btllib::NtHash::NtHash
            NtHash(const std::string &seq, hashing_internals::NUM_HASHES_TYPE num_hashes, hashing_internals::K_TYPE k, size_t pos=0)
            Definition: nthash_kmer.hpp:278
            -
            btllib::NtHash::roll_back
            bool roll_back()
            Definition: nthash_kmer.hpp:339
            -
            btllib::BlindNtHash::roll
            void roll(char char_in)
            Definition: nthash_kmer.hpp:567
            -
            btllib::BlindNtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_kmer.hpp:616
            -
            btllib::BlindNtHash::peek
            void peek(char char_in)
            Definition: nthash_kmer.hpp:593
            -
            btllib::BlindNtHash::roll_back
            void roll_back(char char_in)
            Definition: nthash_kmer.hpp:580
            -
            btllib::BlindNtHash::get_hash_num
            hashing_internals::NUM_HASHES_TYPE get_hash_num() const
            Definition: nthash_kmer.hpp:629
            -
            btllib::NtHash::get_hash_num
            hashing_internals::NUM_HASHES_TYPE get_hash_num() const
            Definition: nthash_kmer.hpp:456
            -
            btllib::BlindNtHash::get_reverse_hash
            uint64_t get_reverse_hash() const
            Definition: nthash_kmer.hpp:647
            +
            btllib::NtHash::roll_back
            bool roll_back()
            Definition: nthash_kmer.hpp:359
            +
            btllib::BlindNtHash::roll
            void roll(char char_in)
            Definition: nthash_kmer.hpp:587
            +
            btllib::BlindNtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_kmer.hpp:636
            +
            btllib::BlindNtHash::peek
            void peek(char char_in)
            Definition: nthash_kmer.hpp:613
            +
            btllib::BlindNtHash::roll_back
            void roll_back(char char_in)
            Definition: nthash_kmer.hpp:600
            +
            btllib::BlindNtHash::get_hash_num
            hashing_internals::NUM_HASHES_TYPE get_hash_num() const
            Definition: nthash_kmer.hpp:649
            +
            btllib::NtHash::get_hash_num
            hashing_internals::NUM_HASHES_TYPE get_hash_num() const
            Definition: nthash_kmer.hpp:476
            +
            btllib::BlindNtHash::get_reverse_hash
            uint64_t get_reverse_hash() const
            Definition: nthash_kmer.hpp:667
            diff --git a/docs/nthash__seed_8hpp_source.html b/docs/nthash__seed_8hpp_source.html index 93732a16..0253fc1b 100644 --- a/docs/nthash__seed_8hpp_source.html +++ b/docs/nthash__seed_8hpp_source.html @@ -587,377 +587,397 @@
            650 
            651  SeedNtHash(SeedNtHash&&) = default;
            652 
            -
            658  bool roll()
            -
            659  {
            -
            660  if (!initialized) {
            -
            661  return init();
            -
            662  }
            -
            663  if (pos >= seq_len - k) {
            -
            664  return false;
            -
            665  }
            -
            666  if (SEED_TAB[(unsigned char)seq[pos + k]] == SEED_N) {
            -
            667  pos += k;
            -
            668  return init();
            -
            669  }
            -
            670  ntmsm64(seq + pos,
            -
            671  blocks,
            -
            672  monomers,
            -
            673  k,
            -
            674  blocks.size(),
            -
            675  num_hashes_per_seed,
            -
            676  fwd_hash_nomonos.get(),
            -
            677  rev_hash_nomonos.get(),
            -
            678  fwd_hash.get(),
            -
            679  rev_hash.get(),
            -
            680  hash_arr.get());
            -
            681  ++pos;
            -
            682  return true;
            -
            683  }
            -
            684 
            -
            689  bool roll_back()
            -
            690  {
            -
            691  if (!initialized) {
            -
            692  return init();
            -
            693  }
            -
            694  if (pos == 0) {
            -
            695  return false;
            -
            696  }
            -
            697  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N && pos >= k) {
            -
            698  pos -= k;
            -
            699  return init();
            -
            700  }
            -
            701  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N) {
            -
            702  return false;
            -
            703  }
            -
            704  ntmsm64l(seq + pos - 1,
            -
            705  blocks,
            -
            706  monomers,
            -
            707  k,
            -
            708  blocks.size(),
            -
            709  num_hashes_per_seed,
            -
            710  fwd_hash_nomonos.get(),
            -
            711  rev_hash_nomonos.get(),
            -
            712  fwd_hash.get(),
            -
            713  rev_hash.get(),
            -
            714  hash_arr.get());
            -
            715  --pos;
            -
            716  return true;
            -
            717  }
            -
            718 
            -
            724  bool peek()
            -
            725  {
            -
            726  if (pos >= seq_len - k) {
            -
            727  return false;
            -
            728  }
            -
            729  return peek(seq[pos + k]);
            -
            730  }
            -
            731 
            -
            736  bool peek_back()
            -
            737  {
            -
            738  if (pos == 0) {
            -
            739  return false;
            -
            740  }
            -
            741  return peek_back(seq[pos - 1]);
            -
            742  }
            -
            743 
            -
            748  bool peek(char char_in)
            -
            749  {
            -
            750  if (!initialized) {
            -
            751  return init();
            -
            752  }
            -
            753  const std::unique_ptr<uint64_t[]> fwd_hash_nomonos_cpy(
            -
            754  new uint64_t[blocks.size()]);
            -
            755  const std::unique_ptr<uint64_t[]> rev_hash_nomonos_cpy(
            -
            756  new uint64_t[blocks.size()]);
            -
            757  const std::unique_ptr<uint64_t[]> fwd_hash_cpy(new uint64_t[blocks.size()]);
            -
            758  const std::unique_ptr<uint64_t[]> rev_hash_cpy(new uint64_t[blocks.size()]);
            -
            759  std::memcpy(fwd_hash_nomonos_cpy.get(),
            -
            760  fwd_hash_nomonos.get(),
            -
            761  blocks.size() * sizeof(uint64_t));
            -
            762  std::memcpy(rev_hash_nomonos_cpy.get(),
            -
            763  rev_hash_nomonos.get(),
            -
            764  blocks.size() * sizeof(uint64_t));
            -
            765  std::memcpy(
            -
            766  fwd_hash_cpy.get(), fwd_hash.get(), blocks.size() * sizeof(uint64_t));
            -
            767  std::memcpy(
            -
            768  rev_hash_cpy.get(), rev_hash.get(), blocks.size() * sizeof(uint64_t));
            -
            769  ntmsm64(seq + pos,
            -
            770  char_in,
            -
            771  blocks,
            -
            772  monomers,
            -
            773  k,
            -
            774  blocks.size(),
            -
            775  num_hashes_per_seed,
            -
            776  fwd_hash_nomonos_cpy.get(),
            -
            777  rev_hash_nomonos_cpy.get(),
            -
            778  fwd_hash_cpy.get(),
            -
            779  rev_hash_cpy.get(),
            -
            780  hash_arr.get());
            -
            781  return true;
            -
            782  }
            -
            783 
            -
            788  bool peek_back(char char_in)
            -
            789  {
            -
            790  if (!initialized) {
            -
            791  return init();
            -
            792  }
            -
            793  const std::unique_ptr<uint64_t[]> fwd_hash_nomonos_cpy(
            -
            794  new uint64_t[blocks.size()]);
            -
            795  const std::unique_ptr<uint64_t[]> rev_hash_nomonos_cpy(
            -
            796  new uint64_t[blocks.size()]);
            -
            797  const std::unique_ptr<uint64_t[]> fwd_hash_cpy(new uint64_t[blocks.size()]);
            -
            798  const std::unique_ptr<uint64_t[]> rev_hash_cpy(new uint64_t[blocks.size()]);
            -
            799  std::memcpy(fwd_hash_nomonos_cpy.get(),
            -
            800  fwd_hash_nomonos.get(),
            -
            801  blocks.size() * sizeof(uint64_t));
            -
            802  std::memcpy(rev_hash_nomonos_cpy.get(),
            -
            803  rev_hash_nomonos.get(),
            -
            804  blocks.size() * sizeof(uint64_t));
            -
            805  std::memcpy(
            -
            806  fwd_hash_cpy.get(), fwd_hash.get(), blocks.size() * sizeof(uint64_t));
            -
            807  std::memcpy(
            -
            808  rev_hash_cpy.get(), rev_hash.get(), blocks.size() * sizeof(uint64_t));
            -
            809  ntmsm64l(seq + pos - 1,
            -
            810  char_in,
            -
            811  blocks,
            -
            812  monomers,
            -
            813  k,
            -
            814  blocks.size(),
            -
            815  num_hashes_per_seed,
            -
            816  fwd_hash_nomonos_cpy.get(),
            -
            817  rev_hash_nomonos_cpy.get(),
            -
            818  fwd_hash_cpy.get(),
            -
            819  rev_hash_cpy.get(),
            -
            820  hash_arr.get());
            -
            821  return true;
            -
            822  }
            -
            823 
            -
            828  const uint64_t* hashes() const { return hash_arr.get(); }
            -
            829 
            -
            835  size_t get_pos() const { return pos; }
            -
            836 
            -
            841  unsigned get_hash_num() const { return num_hashes_per_seed * blocks.size(); }
            -
            842 
            -
            847  hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            -
            848  {
            -
            849  return num_hashes_per_seed;
            -
            850  }
            -
            851 
            -
            856  hashing_internals::K_TYPE get_k() const { return k; }
            -
            857 
            -
            862  uint64_t* get_forward_hash() const { return fwd_hash.get(); }
            -
            863 
            -
            868  uint64_t* get_reverse_hash() const { return rev_hash.get(); }
            -
            869 
            -
            870 private:
            -
            871  const char* seq;
            -
            872  const size_t seq_len;
            -
            873  hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed;
            -
            874  hashing_internals::K_TYPE k;
            -
            875  size_t pos;
            -
            876  bool initialized;
            -
            877  std::vector<hashing_internals::SpacedSeedBlocks> blocks;
            -
            878  std::vector<hashing_internals::SpacedSeedMonomers> monomers;
            -
            879  std::unique_ptr<uint64_t[]> fwd_hash_nomonos;
            -
            880  std::unique_ptr<uint64_t[]> rev_hash_nomonos;
            -
            881  std::unique_ptr<uint64_t[]> fwd_hash;
            -
            882  std::unique_ptr<uint64_t[]> rev_hash;
            -
            883  std::unique_ptr<uint64_t[]> hash_arr;
            -
            884 
            -
            889  bool init()
            -
            890  {
            -
            891  unsigned pos_n = 0;
            -
            892  while (pos < seq_len - k + 1 && !ntmsm64(seq + pos,
            -
            893  blocks,
            -
            894  monomers,
            -
            895  k,
            -
            896  blocks.size(),
            -
            897  num_hashes_per_seed,
            -
            898  fwd_hash_nomonos.get(),
            -
            899  rev_hash_nomonos.get(),
            -
            900  fwd_hash.get(),
            -
            901  rev_hash.get(),
            -
            902  pos_n,
            -
            903  hash_arr.get())) {
            -
            904  pos += pos_n + 1;
            -
            905  }
            -
            906  if (pos > seq_len - k) {
            -
            907  return false;
            -
            908  }
            -
            909  initialized = true;
            -
            910  return true;
            -
            911  }
            -
            912 };
            -
            913 
            -
            918 class BlindSeedNtHash
            -
            919 {
            -
            920 
            -
            921 public:
            -
            932  BlindSeedNtHash(const char* seq,
            -
            933  const std::vector<std::string>& seeds,
            -
            934  hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed,
            -
            935  hashing_internals::K_TYPE k,
            -
            936  long pos = 0)
            -
            937  : seq(seq + pos, seq + pos + k)
            -
            938  , num_hashes_per_seed(num_hashes_per_seed)
            -
            939  , k(k)
            -
            940  , pos(pos)
            -
            941  , fwd_hash_nomonos(new uint64_t[seeds.size()])
            -
            942  , rev_hash_nomonos(new uint64_t[seeds.size()])
            -
            943  , fwd_hash(new uint64_t[seeds.size()])
            -
            944  , rev_hash(new uint64_t[seeds.size()])
            -
            945  , hash_arr(new uint64_t[num_hashes_per_seed * seeds.size()])
            -
            946  {
            -
            947  check_seeds(seeds, k);
            -
            948  get_blocks(seeds, blocks, monomers);
            -
            949  unsigned pos_n = 0;
            -
            950  ntmsm64(seq + pos,
            -
            951  blocks,
            -
            952  monomers,
            -
            953  k,
            -
            954  blocks.size(),
            -
            955  num_hashes_per_seed,
            -
            956  fwd_hash_nomonos.get(),
            -
            957  rev_hash_nomonos.get(),
            -
            958  fwd_hash.get(),
            -
            959  rev_hash.get(),
            -
            960  pos_n,
            -
            961  hash_arr.get());
            -
            962  }
            -
            963 
            -
            964  BlindSeedNtHash(const BlindSeedNtHash& seed_nthash)
            -
            965  : seq(seed_nthash.seq)
            -
            966  , num_hashes_per_seed(seed_nthash.num_hashes_per_seed)
            -
            967  , k(seed_nthash.k)
            -
            968  , pos(seed_nthash.pos)
            -
            969  , blocks(seed_nthash.blocks)
            -
            970  , monomers(seed_nthash.monomers)
            -
            971  , fwd_hash_nomonos(new uint64_t[seed_nthash.blocks.size()])
            -
            972  , rev_hash_nomonos(new uint64_t[seed_nthash.blocks.size()])
            -
            973  , fwd_hash(new uint64_t[seed_nthash.blocks.size()])
            -
            974  , rev_hash(new uint64_t[seed_nthash.blocks.size()])
            -
            975  , hash_arr(new uint64_t[num_hashes_per_seed * seed_nthash.blocks.size()])
            -
            976  {
            -
            977  std::memcpy(fwd_hash_nomonos.get(),
            -
            978  seed_nthash.fwd_hash_nomonos.get(),
            -
            979  seed_nthash.blocks.size() * sizeof(uint64_t));
            -
            980  std::memcpy(rev_hash_nomonos.get(),
            -
            981  seed_nthash.rev_hash_nomonos.get(),
            -
            982  seed_nthash.blocks.size() * sizeof(uint64_t));
            -
            983  std::memcpy(fwd_hash.get(),
            -
            984  seed_nthash.fwd_hash.get(),
            -
            985  seed_nthash.blocks.size() * sizeof(uint64_t));
            -
            986  std::memcpy(rev_hash.get(),
            -
            987  seed_nthash.rev_hash.get(),
            -
            988  seed_nthash.blocks.size() * sizeof(uint64_t));
            -
            989  std::memcpy(hash_arr.get(),
            -
            990  seed_nthash.hash_arr.get(),
            -
            991  num_hashes_per_seed * seed_nthash.blocks.size() *
            -
            992  sizeof(uint64_t));
            -
            993  }
            -
            994 
            -
            995  BlindSeedNtHash(BlindSeedNtHash&&) = default;
            -
            996 
            -
            1002  void roll(char char_in)
            -
            1003  {
            -
            1004  seq.push_back(char_in);
            -
            1005  ntmsm64(seq,
            -
            1006  blocks,
            -
            1007  monomers,
            -
            1008  k,
            -
            1009  blocks.size(),
            -
            1010  num_hashes_per_seed,
            -
            1011  fwd_hash_nomonos.get(),
            -
            1012  rev_hash_nomonos.get(),
            -
            1013  fwd_hash.get(),
            -
            1014  rev_hash.get(),
            -
            1015  hash_arr.get());
            -
            1016  seq.pop_front();
            -
            1017  ++pos;
            -
            1018  }
            +
            657  void set_seq(const std::string& seq, size_t pos = 0)
            +
            658  {
            +
            659  this->seq = seq.data();
            +
            660  this->seq_len = seq.size();
            +
            661  this->pos = pos;
            +
            662  this->initialized = false;
            +
            663  this->fwd_hash.reset(new uint64_t[blocks.size()]);
            +
            664  this->rev_hash.reset(new uint64_t[blocks.size()]);
            +
            665  this->hash_arr.reset(new uint64_t[blocks.size() * num_hashes_per_seed]);
            +
            666  check_error(this->seq_len < k,
            +
            667  "SeedNtHash: sequence length (" +
            +
            668  std::to_string(this->seq_len) + ") is smaller than k (" +
            +
            669  std::to_string(k) + ")");
            +
            670  check_error(pos > this->seq_len - k,
            +
            671  "SeedNtHash: passed position (" + std::to_string(pos) +
            +
            672  ") is larger than sequence length (" +
            +
            673  std::to_string(this->seq_len) + ")");
            +
            674  }
            +
            675 
            +
            681  bool roll()
            +
            682  {
            +
            683  if (!initialized) {
            +
            684  return init();
            +
            685  }
            +
            686  if (pos >= seq_len - k) {
            +
            687  return false;
            +
            688  }
            +
            689  if (SEED_TAB[(unsigned char)seq[pos + k]] == SEED_N) {
            +
            690  pos += k;
            +
            691  return init();
            +
            692  }
            +
            693  ntmsm64(seq + pos,
            +
            694  blocks,
            +
            695  monomers,
            +
            696  k,
            +
            697  blocks.size(),
            +
            698  num_hashes_per_seed,
            +
            699  fwd_hash_nomonos.get(),
            +
            700  rev_hash_nomonos.get(),
            +
            701  fwd_hash.get(),
            +
            702  rev_hash.get(),
            +
            703  hash_arr.get());
            +
            704  ++pos;
            +
            705  return true;
            +
            706  }
            +
            707 
            +
            712  bool roll_back()
            +
            713  {
            +
            714  if (!initialized) {
            +
            715  return init();
            +
            716  }
            +
            717  if (pos == 0) {
            +
            718  return false;
            +
            719  }
            +
            720  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N && pos >= k) {
            +
            721  pos -= k;
            +
            722  return init();
            +
            723  }
            +
            724  if (SEED_TAB[(unsigned char)seq[pos - 1]] == SEED_N) {
            +
            725  return false;
            +
            726  }
            +
            727  ntmsm64l(seq + pos - 1,
            +
            728  blocks,
            +
            729  monomers,
            +
            730  k,
            +
            731  blocks.size(),
            +
            732  num_hashes_per_seed,
            +
            733  fwd_hash_nomonos.get(),
            +
            734  rev_hash_nomonos.get(),
            +
            735  fwd_hash.get(),
            +
            736  rev_hash.get(),
            +
            737  hash_arr.get());
            +
            738  --pos;
            +
            739  return true;
            +
            740  }
            +
            741 
            +
            747  bool peek()
            +
            748  {
            +
            749  if (pos >= seq_len - k) {
            +
            750  return false;
            +
            751  }
            +
            752  return peek(seq[pos + k]);
            +
            753  }
            +
            754 
            +
            759  bool peek_back()
            +
            760  {
            +
            761  if (pos == 0) {
            +
            762  return false;
            +
            763  }
            +
            764  return peek_back(seq[pos - 1]);
            +
            765  }
            +
            766 
            +
            771  bool peek(char char_in)
            +
            772  {
            +
            773  if (!initialized) {
            +
            774  return init();
            +
            775  }
            +
            776  const std::unique_ptr<uint64_t[]> fwd_hash_nomonos_cpy(
            +
            777  new uint64_t[blocks.size()]);
            +
            778  const std::unique_ptr<uint64_t[]> rev_hash_nomonos_cpy(
            +
            779  new uint64_t[blocks.size()]);
            +
            780  const std::unique_ptr<uint64_t[]> fwd_hash_cpy(new uint64_t[blocks.size()]);
            +
            781  const std::unique_ptr<uint64_t[]> rev_hash_cpy(new uint64_t[blocks.size()]);
            +
            782  std::memcpy(fwd_hash_nomonos_cpy.get(),
            +
            783  fwd_hash_nomonos.get(),
            +
            784  blocks.size() * sizeof(uint64_t));
            +
            785  std::memcpy(rev_hash_nomonos_cpy.get(),
            +
            786  rev_hash_nomonos.get(),
            +
            787  blocks.size() * sizeof(uint64_t));
            +
            788  std::memcpy(
            +
            789  fwd_hash_cpy.get(), fwd_hash.get(), blocks.size() * sizeof(uint64_t));
            +
            790  std::memcpy(
            +
            791  rev_hash_cpy.get(), rev_hash.get(), blocks.size() * sizeof(uint64_t));
            +
            792  ntmsm64(seq + pos,
            +
            793  char_in,
            +
            794  blocks,
            +
            795  monomers,
            +
            796  k,
            +
            797  blocks.size(),
            +
            798  num_hashes_per_seed,
            +
            799  fwd_hash_nomonos_cpy.get(),
            +
            800  rev_hash_nomonos_cpy.get(),
            +
            801  fwd_hash_cpy.get(),
            +
            802  rev_hash_cpy.get(),
            +
            803  hash_arr.get());
            +
            804  return true;
            +
            805  }
            +
            806 
            +
            811  bool peek_back(char char_in)
            +
            812  {
            +
            813  if (!initialized) {
            +
            814  return init();
            +
            815  }
            +
            816  const std::unique_ptr<uint64_t[]> fwd_hash_nomonos_cpy(
            +
            817  new uint64_t[blocks.size()]);
            +
            818  const std::unique_ptr<uint64_t[]> rev_hash_nomonos_cpy(
            +
            819  new uint64_t[blocks.size()]);
            +
            820  const std::unique_ptr<uint64_t[]> fwd_hash_cpy(new uint64_t[blocks.size()]);
            +
            821  const std::unique_ptr<uint64_t[]> rev_hash_cpy(new uint64_t[blocks.size()]);
            +
            822  std::memcpy(fwd_hash_nomonos_cpy.get(),
            +
            823  fwd_hash_nomonos.get(),
            +
            824  blocks.size() * sizeof(uint64_t));
            +
            825  std::memcpy(rev_hash_nomonos_cpy.get(),
            +
            826  rev_hash_nomonos.get(),
            +
            827  blocks.size() * sizeof(uint64_t));
            +
            828  std::memcpy(
            +
            829  fwd_hash_cpy.get(), fwd_hash.get(), blocks.size() * sizeof(uint64_t));
            +
            830  std::memcpy(
            +
            831  rev_hash_cpy.get(), rev_hash.get(), blocks.size() * sizeof(uint64_t));
            +
            832  ntmsm64l(seq + pos - 1,
            +
            833  char_in,
            +
            834  blocks,
            +
            835  monomers,
            +
            836  k,
            +
            837  blocks.size(),
            +
            838  num_hashes_per_seed,
            +
            839  fwd_hash_nomonos_cpy.get(),
            +
            840  rev_hash_nomonos_cpy.get(),
            +
            841  fwd_hash_cpy.get(),
            +
            842  rev_hash_cpy.get(),
            +
            843  hash_arr.get());
            +
            844  return true;
            +
            845  }
            +
            846 
            +
            851  const uint64_t* hashes() const { return hash_arr.get(); }
            +
            852 
            +
            858  size_t get_pos() const { return pos; }
            +
            859 
            +
            864  unsigned get_hash_num() const { return num_hashes_per_seed * blocks.size(); }
            +
            865 
            +
            870  hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            +
            871  {
            +
            872  return num_hashes_per_seed;
            +
            873  }
            +
            874 
            +
            879  hashing_internals::K_TYPE get_k() const { return k; }
            +
            880 
            +
            885  uint64_t* get_forward_hash() const { return fwd_hash.get(); }
            +
            886 
            +
            891  uint64_t* get_reverse_hash() const { return rev_hash.get(); }
            +
            892 
            +
            893 private:
            +
            894  const char* seq;
            +
            895  size_t seq_len;
            +
            896  hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed;
            +
            897  hashing_internals::K_TYPE k;
            +
            898  size_t pos;
            +
            899  bool initialized;
            +
            900  std::vector<hashing_internals::SpacedSeedBlocks> blocks;
            +
            901  std::vector<hashing_internals::SpacedSeedMonomers> monomers;
            +
            902  std::unique_ptr<uint64_t[]> fwd_hash_nomonos;
            +
            903  std::unique_ptr<uint64_t[]> rev_hash_nomonos;
            +
            904  std::unique_ptr<uint64_t[]> fwd_hash;
            +
            905  std::unique_ptr<uint64_t[]> rev_hash;
            +
            906  std::unique_ptr<uint64_t[]> hash_arr;
            +
            907 
            +
            912  bool init()
            +
            913  {
            +
            914  unsigned pos_n = 0;
            +
            915  while (pos < seq_len - k + 1 && !ntmsm64(seq + pos,
            +
            916  blocks,
            +
            917  monomers,
            +
            918  k,
            +
            919  blocks.size(),
            +
            920  num_hashes_per_seed,
            +
            921  fwd_hash_nomonos.get(),
            +
            922  rev_hash_nomonos.get(),
            +
            923  fwd_hash.get(),
            +
            924  rev_hash.get(),
            +
            925  pos_n,
            +
            926  hash_arr.get())) {
            +
            927  pos += pos_n + 1;
            +
            928  }
            +
            929  if (pos > seq_len - k) {
            +
            930  return false;
            +
            931  }
            +
            932  initialized = true;
            +
            933  return true;
            +
            934  }
            +
            935 };
            +
            936 
            +
            941 class BlindSeedNtHash
            +
            942 {
            +
            943 
            +
            944 public:
            +
            955  BlindSeedNtHash(const char* seq,
            +
            956  const std::vector<std::string>& seeds,
            +
            957  hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed,
            +
            958  hashing_internals::K_TYPE k,
            +
            959  long pos = 0)
            +
            960  : seq(seq + pos, seq + pos + k)
            +
            961  , num_hashes_per_seed(num_hashes_per_seed)
            +
            962  , k(k)
            +
            963  , pos(pos)
            +
            964  , fwd_hash_nomonos(new uint64_t[seeds.size()])
            +
            965  , rev_hash_nomonos(new uint64_t[seeds.size()])
            +
            966  , fwd_hash(new uint64_t[seeds.size()])
            +
            967  , rev_hash(new uint64_t[seeds.size()])
            +
            968  , hash_arr(new uint64_t[num_hashes_per_seed * seeds.size()])
            +
            969  {
            +
            970  check_seeds(seeds, k);
            +
            971  get_blocks(seeds, blocks, monomers);
            +
            972  unsigned pos_n = 0;
            +
            973  ntmsm64(seq + pos,
            +
            974  blocks,
            +
            975  monomers,
            +
            976  k,
            +
            977  blocks.size(),
            +
            978  num_hashes_per_seed,
            +
            979  fwd_hash_nomonos.get(),
            +
            980  rev_hash_nomonos.get(),
            +
            981  fwd_hash.get(),
            +
            982  rev_hash.get(),
            +
            983  pos_n,
            +
            984  hash_arr.get());
            +
            985  }
            +
            986 
            +
            987  BlindSeedNtHash(const BlindSeedNtHash& seed_nthash)
            +
            988  : seq(seed_nthash.seq)
            +
            989  , num_hashes_per_seed(seed_nthash.num_hashes_per_seed)
            +
            990  , k(seed_nthash.k)
            +
            991  , pos(seed_nthash.pos)
            +
            992  , blocks(seed_nthash.blocks)
            +
            993  , monomers(seed_nthash.monomers)
            +
            994  , fwd_hash_nomonos(new uint64_t[seed_nthash.blocks.size()])
            +
            995  , rev_hash_nomonos(new uint64_t[seed_nthash.blocks.size()])
            +
            996  , fwd_hash(new uint64_t[seed_nthash.blocks.size()])
            +
            997  , rev_hash(new uint64_t[seed_nthash.blocks.size()])
            +
            998  , hash_arr(new uint64_t[num_hashes_per_seed * seed_nthash.blocks.size()])
            +
            999  {
            +
            1000  std::memcpy(fwd_hash_nomonos.get(),
            +
            1001  seed_nthash.fwd_hash_nomonos.get(),
            +
            1002  seed_nthash.blocks.size() * sizeof(uint64_t));
            +
            1003  std::memcpy(rev_hash_nomonos.get(),
            +
            1004  seed_nthash.rev_hash_nomonos.get(),
            +
            1005  seed_nthash.blocks.size() * sizeof(uint64_t));
            +
            1006  std::memcpy(fwd_hash.get(),
            +
            1007  seed_nthash.fwd_hash.get(),
            +
            1008  seed_nthash.blocks.size() * sizeof(uint64_t));
            +
            1009  std::memcpy(rev_hash.get(),
            +
            1010  seed_nthash.rev_hash.get(),
            +
            1011  seed_nthash.blocks.size() * sizeof(uint64_t));
            +
            1012  std::memcpy(hash_arr.get(),
            +
            1013  seed_nthash.hash_arr.get(),
            +
            1014  num_hashes_per_seed * seed_nthash.blocks.size() *
            +
            1015  sizeof(uint64_t));
            +
            1016  }
            +
            1017 
            +
            1018  BlindSeedNtHash(BlindSeedNtHash&&) = default;
            1019 
            -
            1023  void roll_back(char char_in)
            -
            1024  {
            -
            1025  seq.push_front(char_in);
            -
            1026  ntmsm64l(seq,
            -
            1027  blocks,
            -
            1028  monomers,
            -
            1029  k,
            -
            1030  blocks.size(),
            -
            1031  num_hashes_per_seed,
            -
            1032  fwd_hash_nomonos.get(),
            -
            1033  rev_hash_nomonos.get(),
            -
            1034  fwd_hash.get(),
            -
            1035  rev_hash.get(),
            -
            1036  hash_arr.get());
            -
            1037  seq.pop_back();
            -
            1038  --pos;
            -
            1039  }
            -
            1040 
            -
            1045  const uint64_t* hashes() const { return hash_arr.get(); }
            -
            1046 
            -
            1052  long get_pos() const { return pos; }
            -
            1053 
            -
            1058  unsigned get_hash_num() const { return num_hashes_per_seed * blocks.size(); }
            -
            1059 
            -
            1064  hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            -
            1065  {
            -
            1066  return num_hashes_per_seed;
            -
            1067  }
            -
            1068 
            -
            1073  hashing_internals::K_TYPE get_k() const { return k; }
            -
            1074 
            -
            1079  uint64_t* get_forward_hash() const { return fwd_hash.get(); }
            -
            1080 
            -
            1085  uint64_t* get_reverse_hash() const { return rev_hash.get(); }
            -
            1086 
            -
            1087 private:
            -
            1088  std::deque<char> seq;
            -
            1089  hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed;
            -
            1090  hashing_internals::K_TYPE k;
            -
            1091  long pos;
            -
            1092  std::vector<hashing_internals::SpacedSeedBlocks> blocks;
            -
            1093  std::vector<hashing_internals::SpacedSeedMonomers> monomers;
            -
            1094  std::unique_ptr<uint64_t[]> fwd_hash_nomonos;
            -
            1095  std::unique_ptr<uint64_t[]> rev_hash_nomonos;
            -
            1096  std::unique_ptr<uint64_t[]> fwd_hash;
            -
            1097  std::unique_ptr<uint64_t[]> rev_hash;
            -
            1098  std::unique_ptr<uint64_t[]> hash_arr;
            -
            1099 };
            -
            1100 
            -
            1101 } // namespace btllib
            -
            btllib::BlindSeedNtHash::get_hash_num
            unsigned get_hash_num() const
            Definition: nthash_seed.hpp:1058
            -
            btllib::BlindSeedNtHash::get_reverse_hash
            uint64_t * get_reverse_hash() const
            Definition: nthash_seed.hpp:1085
            -
            btllib::SeedNtHash::peek
            bool peek(char char_in)
            Definition: nthash_seed.hpp:748
            -
            btllib::BlindSeedNtHash::get_forward_hash
            uint64_t * get_forward_hash() const
            Definition: nthash_seed.hpp:1079
            +
            1025  void roll(char char_in)
            +
            1026  {
            +
            1027  seq.push_back(char_in);
            +
            1028  ntmsm64(seq,
            +
            1029  blocks,
            +
            1030  monomers,
            +
            1031  k,
            +
            1032  blocks.size(),
            +
            1033  num_hashes_per_seed,
            +
            1034  fwd_hash_nomonos.get(),
            +
            1035  rev_hash_nomonos.get(),
            +
            1036  fwd_hash.get(),
            +
            1037  rev_hash.get(),
            +
            1038  hash_arr.get());
            +
            1039  seq.pop_front();
            +
            1040  ++pos;
            +
            1041  }
            +
            1042 
            +
            1046  void roll_back(char char_in)
            +
            1047  {
            +
            1048  seq.push_front(char_in);
            +
            1049  ntmsm64l(seq,
            +
            1050  blocks,
            +
            1051  monomers,
            +
            1052  k,
            +
            1053  blocks.size(),
            +
            1054  num_hashes_per_seed,
            +
            1055  fwd_hash_nomonos.get(),
            +
            1056  rev_hash_nomonos.get(),
            +
            1057  fwd_hash.get(),
            +
            1058  rev_hash.get(),
            +
            1059  hash_arr.get());
            +
            1060  seq.pop_back();
            +
            1061  --pos;
            +
            1062  }
            +
            1063 
            +
            1068  const uint64_t* hashes() const { return hash_arr.get(); }
            +
            1069 
            +
            1075  long get_pos() const { return pos; }
            +
            1076 
            +
            1081  unsigned get_hash_num() const { return num_hashes_per_seed * blocks.size(); }
            +
            1082 
            +
            1087  hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            +
            1088  {
            +
            1089  return num_hashes_per_seed;
            +
            1090  }
            +
            1091 
            +
            1096  hashing_internals::K_TYPE get_k() const { return k; }
            +
            1097 
            +
            1102  uint64_t* get_forward_hash() const { return fwd_hash.get(); }
            +
            1103 
            +
            1108  uint64_t* get_reverse_hash() const { return rev_hash.get(); }
            +
            1109 
            +
            1110 private:
            +
            1111  std::deque<char> seq;
            +
            1112  hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed;
            +
            1113  hashing_internals::K_TYPE k;
            +
            1114  long pos;
            +
            1115  std::vector<hashing_internals::SpacedSeedBlocks> blocks;
            +
            1116  std::vector<hashing_internals::SpacedSeedMonomers> monomers;
            +
            1117  std::unique_ptr<uint64_t[]> fwd_hash_nomonos;
            +
            1118  std::unique_ptr<uint64_t[]> rev_hash_nomonos;
            +
            1119  std::unique_ptr<uint64_t[]> fwd_hash;
            +
            1120  std::unique_ptr<uint64_t[]> rev_hash;
            +
            1121  std::unique_ptr<uint64_t[]> hash_arr;
            +
            1122 };
            +
            1123 
            +
            1124 } // namespace btllib
            +
            btllib::BlindSeedNtHash::get_hash_num
            unsigned get_hash_num() const
            Definition: nthash_seed.hpp:1081
            +
            btllib::BlindSeedNtHash::get_reverse_hash
            uint64_t * get_reverse_hash() const
            Definition: nthash_seed.hpp:1108
            +
            btllib::SeedNtHash::peek
            bool peek(char char_in)
            Definition: nthash_seed.hpp:771
            +
            btllib::SeedNtHash::set_seq
            void set_seq(const std::string &seq, size_t pos=0)
            Definition: nthash_seed.hpp:657
            +
            btllib::BlindSeedNtHash::get_forward_hash
            uint64_t * get_forward_hash() const
            Definition: nthash_seed.hpp:1102
            btllib::SeedNtHash::SeedNtHash
            SeedNtHash(const std::string &seq, const std::vector< std::string > &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, size_t pos=0)
            Definition: nthash_seed.hpp:563
            btllib::parse_seeds
            std::vector< std::vector< unsigned > > parse_seeds(const std::vector< std::string > &seed_strings)
            Definition: nthash_seed.hpp:496
            -
            btllib::SeedNtHash::get_forward_hash
            uint64_t * get_forward_hash() const
            Definition: nthash_seed.hpp:862
            -
            btllib::BlindSeedNtHash::BlindSeedNtHash
            BlindSeedNtHash(const char *seq, const std::vector< std::string > &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, long pos=0)
            Definition: nthash_seed.hpp:932
            -
            btllib::BlindSeedNtHash::get_pos
            long get_pos() const
            Definition: nthash_seed.hpp:1052
            -
            btllib::BlindSeedNtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_seed.hpp:1073
            +
            btllib::SeedNtHash::get_forward_hash
            uint64_t * get_forward_hash() const
            Definition: nthash_seed.hpp:885
            +
            btllib::BlindSeedNtHash::BlindSeedNtHash
            BlindSeedNtHash(const char *seq, const std::vector< std::string > &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, long pos=0)
            Definition: nthash_seed.hpp:955
            +
            btllib::BlindSeedNtHash::get_pos
            long get_pos() const
            Definition: nthash_seed.hpp:1075
            +
            btllib::BlindSeedNtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_seed.hpp:1096
            btllib::check_warning
            void check_warning(bool condition, const std::string &msg)
            btllib::SeedNtHash::SeedNtHash
            SeedNtHash(const std::string &seq, const std::vector< std::vector< unsigned >> &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, size_t pos=0)
            Definition: nthash_seed.hpp:612
            -
            btllib::BlindSeedNtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_seed.hpp:1045
            -
            btllib::SeedNtHash::roll_back
            bool roll_back()
            Definition: nthash_seed.hpp:689
            -
            btllib::BlindSeedNtHash::roll
            void roll(char char_in)
            Definition: nthash_seed.hpp:1002
            -
            btllib::SeedNtHash::get_reverse_hash
            uint64_t * get_reverse_hash() const
            Definition: nthash_seed.hpp:868
            +
            btllib::BlindSeedNtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_seed.hpp:1068
            +
            btllib::SeedNtHash::roll_back
            bool roll_back()
            Definition: nthash_seed.hpp:712
            +
            btllib::BlindSeedNtHash::roll
            void roll(char char_in)
            Definition: nthash_seed.hpp:1025
            +
            btllib::SeedNtHash::get_reverse_hash
            uint64_t * get_reverse_hash() const
            Definition: nthash_seed.hpp:891
            btllib::check_error
            void check_error(bool condition, const std::string &msg)
            -
            btllib::SeedNtHash::peek_back
            bool peek_back()
            Definition: nthash_seed.hpp:736
            -
            btllib::SeedNtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_seed.hpp:828
            -
            btllib::SeedNtHash::get_hash_num_per_seed
            hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            Definition: nthash_seed.hpp:847
            -
            btllib::BlindSeedNtHash::get_hash_num_per_seed
            hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            Definition: nthash_seed.hpp:1064
            -
            btllib::BlindSeedNtHash
            Definition: nthash_seed.hpp:918
            -
            btllib::SeedNtHash::get_pos
            size_t get_pos() const
            Definition: nthash_seed.hpp:835
            +
            btllib::SeedNtHash::peek_back
            bool peek_back()
            Definition: nthash_seed.hpp:759
            +
            btllib::SeedNtHash::hashes
            const uint64_t * hashes() const
            Definition: nthash_seed.hpp:851
            +
            btllib::SeedNtHash::get_hash_num_per_seed
            hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            Definition: nthash_seed.hpp:870
            +
            btllib::BlindSeedNtHash::get_hash_num_per_seed
            hashing_internals::NUM_HASHES_TYPE get_hash_num_per_seed() const
            Definition: nthash_seed.hpp:1087
            +
            btllib::BlindSeedNtHash
            Definition: nthash_seed.hpp:941
            +
            btllib::SeedNtHash::get_pos
            size_t get_pos() const
            Definition: nthash_seed.hpp:858
            btllib::SeedNtHash
            Definition: nthash_seed.hpp:516
            -
            btllib::SeedNtHash::get_hash_num
            unsigned get_hash_num() const
            Definition: nthash_seed.hpp:841
            -
            btllib::SeedNtHash::roll
            bool roll()
            Definition: nthash_seed.hpp:658
            -
            btllib::SeedNtHash::peek
            bool peek()
            Definition: nthash_seed.hpp:724
            -
            btllib::BlindSeedNtHash::roll_back
            void roll_back(char char_in)
            Definition: nthash_seed.hpp:1023
            +
            btllib::SeedNtHash::get_hash_num
            unsigned get_hash_num() const
            Definition: nthash_seed.hpp:864
            +
            btllib::SeedNtHash::roll
            bool roll()
            Definition: nthash_seed.hpp:681
            +
            btllib::SeedNtHash::peek
            bool peek()
            Definition: nthash_seed.hpp:747
            +
            btllib::BlindSeedNtHash::roll_back
            void roll_back(char char_in)
            Definition: nthash_seed.hpp:1046
            btllib::SeedNtHash::SeedNtHash
            SeedNtHash(const char *seq, size_t seq_len, const std::vector< std::vector< unsigned >> &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, size_t pos=0)
            Definition: nthash_seed.hpp:582
            btllib::SeedNtHash::SeedNtHash
            SeedNtHash(const char *seq, size_t seq_len, const std::vector< std::string > &seeds, hashing_internals::NUM_HASHES_TYPE num_hashes_per_seed, hashing_internals::K_TYPE k, size_t pos=0)
            Definition: nthash_seed.hpp:530
            -
            btllib::SeedNtHash::peek_back
            bool peek_back(char char_in)
            Definition: nthash_seed.hpp:788
            -
            btllib::SeedNtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_seed.hpp:856
            +
            btllib::SeedNtHash::peek_back
            bool peek_back(char char_in)
            Definition: nthash_seed.hpp:811
            +
            btllib::SeedNtHash::get_k
            hashing_internals::K_TYPE get_k() const
            Definition: nthash_seed.hpp:879
            diff --git a/docs/search/all_73.js b/docs/search/all_73.js index 0627bf44..a974bd2a 100644 --- a/docs/search/all_73.js +++ b/docs/search/all_73.js @@ -13,6 +13,7 @@ var searchData= ['seqwriter',['SeqWriter',['../classbtllib_1_1SeqWriter.html',1,'btllib']]], ['seqwriter',['SeqWriter',['../classbtllib_1_1SeqWriter.html#a6271cffe77701558f0997532a7e58d43',1,'btllib::SeqWriter']]], ['set_5fseed',['set_seed',['../classbtllib_1_1RandSeq.html#a0a481fe231a3ca8021aa807f2bd7d97b',1,'btllib::RandSeq']]], + ['set_5fseq',['set_seq',['../classbtllib_1_1NtHash.html#a419ba8aaab69033241dece2511082ad7',1,'btllib::NtHash::set_seq()'],['../classbtllib_1_1SeedNtHash.html#a49ff99a34ead2b1571a05806607746d0',1,'btllib::SeedNtHash::set_seq()']]], ['short_5fmode',['SHORT_MODE',['../structbtllib_1_1Indexlr_1_1Flag.html#ad901a6d96362ce4b250fa144fe9a76ef',1,'btllib::Indexlr::Flag::SHORT_MODE()'],['../structbtllib_1_1SeqReader_1_1Flag.html#ab0aba3f99ab4159205621e2242c6e18f',1,'btllib::SeqReader::Flag::SHORT_MODE()']]], ['split',['split',['../namespacebtllib.html#a47fd4694017baaa6babe345282e2c96b',1,'btllib']]], ['startswith',['startswith',['../namespacebtllib.html#acc6df2bfa872c7b1e830cf314d20e306',1,'btllib']]] diff --git a/docs/search/functions_73.js b/docs/search/functions_73.js index 674a0ca8..7dbbc5a5 100644 --- a/docs/search/functions_73.js +++ b/docs/search/functions_73.js @@ -7,6 +7,7 @@ var searchData= ['seqreader',['SeqReader',['../classbtllib_1_1SeqReader.html#a03cc4e39fffc556a2f05c30bc6d3731d',1,'btllib::SeqReader']]], ['seqwriter',['SeqWriter',['../classbtllib_1_1SeqWriter.html#a6271cffe77701558f0997532a7e58d43',1,'btllib::SeqWriter']]], ['set_5fseed',['set_seed',['../classbtllib_1_1RandSeq.html#a0a481fe231a3ca8021aa807f2bd7d97b',1,'btllib::RandSeq']]], + ['set_5fseq',['set_seq',['../classbtllib_1_1NtHash.html#a419ba8aaab69033241dece2511082ad7',1,'btllib::NtHash::set_seq()'],['../classbtllib_1_1SeedNtHash.html#a49ff99a34ead2b1571a05806607746d0',1,'btllib::SeedNtHash::set_seq()']]], ['split',['split',['../namespacebtllib.html#a47fd4694017baaa6babe345282e2c96b',1,'btllib']]], ['startswith',['startswith',['../namespacebtllib.html#acc6df2bfa872c7b1e830cf314d20e306',1,'btllib']]] ];