seqan::hibf::counting_vector< value_t > Class Template Reference

A data structure that behaves like a std::vector and can be used to consolidate the results of multiple calls to seqan::hibf::interleaved_bloom_filter::membership_agent_type::bulk_contains. More...

#include <hibf/misc/counting_vector.hpp>

Inheritance diagram for seqan::hibf::counting_vector< value_t >:

Public Member Functions
counting_vector &	operator+= (bit_vector const &bit_vector)
	Bin-wise adds the bits of a seqan::hibf::bit_vector.
counting_vector &	operator+= (counting_vector const &rhs)
	Bin-wise addition of two seqan::hibf::counting_vectors.
counting_vector &	operator-= (bit_vector const &bit_vector)
	Bin-wise subtracts the bits of a seqan::hibf::bit_vector.
counting_vector &	operator-= (counting_vector const &rhs)
	Bin-wise subtraction of two seqan::hibf::counting_vectors.
Constructors, destructor and assignment
	counting_vector ()=default
	Defaulted.
	counting_vector (counting_vector const &)=default
	Defaulted.
counting_vector &	operator= (counting_vector const &)=default
	Defaulted.
	counting_vector (counting_vector &&)=default
	Defaulted.
counting_vector &	operator= (counting_vector &&)=default
	Defaulted.
	~counting_vector ()=default
	Defaulted.
Public Member Functions inherited from std::vector< value_t, seqan::hibf::contrib::aligned_allocator< value_t, 64u > >
T	assign (T... args)
T	at (T... args)
T	back (T... args)
T	begin (T... args)
T	capacity (T... args)
T	cbegin (T... args)
T	cend (T... args)
T	clear (T... args)
T	crbegin (T... args)
T	crend (T... args)
T	data (T... args)
T	emplace (T... args)
T	emplace_back (T... args)
T	empty (T... args)
T	end (T... args)
T	erase (T... args)
T	front (T... args)
T	get_allocator (T... args)
T	insert (T... args)
T	max_size (T... args)
T	operator= (T... args)
T	operator[] (T... args)
T	pop_back (T... args)
T	push_back (T... args)
T	rbegin (T... args)
T	rend (T... args)
T	reserve (T... args)
T	resize (T... args)
T	shrink_to_fit (T... args)
T	size (T... args)
T	swap (T... args)
T	vector (T... args)
T	~vector (T... args)

Detailed Description

template<std::integral value_t>
class seqan::hibf::counting_vector< value_t >

A data structure that behaves like a std::vector and can be used to consolidate the results of multiple calls to seqan::hibf::interleaved_bloom_filter::membership_agent_type::bulk_contains.

Template Parameters

value_t

The type of the count. Must model std::integral.

When using the seqan::hibf::interleaved_bloom_filter::membership_agent_type::bulk_contains operation, a common use case is to add up, for example, the results for all k-mers in a query. This yields, for each bin, the number of k-mers of a query that are in the respective bin. Such information can be used to apply further filtering or abundance estimation based on the k-mer counts.

The seqan::hibf::counting_vector offers an easy way to add up the individual seqan::hibf::bit_vector by offering an += operator.

The value_t template parameter should be chosen in a way that no overflow occurs if all calls to bulk_contains return a hit for a specific bin. For example, uint8_t will suffice when processing short Illumina reads, whereas long reads will require at least uint32_t.

Example

// SPDX-FileCopyrightText: 2006-2025, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <cstdint> // for uint16_t
 
#include <hibf/interleaved_bloom_filter.hpp> // for interleaved_bloom_filter, bin_index, bin_count, bin_size
#include <hibf/misc/counting_vector.hpp>     // for counting_vector
#include <hibf/misc/print.hpp>               // for print, print_t
 
int main()
{
    seqan::hibf::interleaved_bloom_filter ibf{seqan::hibf::bin_count{12u}, seqan::hibf::bin_size{8192u}};
    ibf.emplace(126, seqan::hibf::bin_index{0u});
    ibf.emplace(126, seqan::hibf::bin_index{3u});
    ibf.emplace(126, seqan::hibf::bin_index{9u});
    ibf.emplace(712, seqan::hibf::bin_index{3u});
    ibf.emplace(237, seqan::hibf::bin_index{9u});
 
    // The counting_vector must be at least as big as the number of bins.
    seqan::hibf::counting_vector<uint16_t> counts(12, 0);
 
    auto agent = ibf.membership_agent();
 
    counts += agent.bulk_contains(712); // `counts` contains the number of occurrences of 712 in each bin.
    seqan::hibf::print(counts);         // prints [0,0,0,1,0,0,0,0,0,0,0,0]
 
    counts += agent.bulk_contains(237); // `counts` contains the number of occurrences of 712 and 237 in each bin.
    seqan::hibf::print(counts);         // prints [0,0,0,1,0,0,0,0,0,1,0,0]
 
    counts += agent.bulk_contains(126); // `counts` contains the number of occurrences of 712, 237 and 126 in each bin.
    seqan::hibf::print(counts);         // prints [1,0,0,2,0,0,0,0,0,2,0,0]
 
    counts += counts;           // multiple counts can also be added together
    seqan::hibf::print(counts); // prints [2,0,0,4,0,0,0,0,0,4,0,0]
}

Member Function Documentation

operator+=() [1/2]

template<std::integral value_t>

counting_vector & seqan::hibf::counting_vector< value_t >::operator+= ( bit_vector const & bit_vector )

inline

Bin-wise adds the bits of a seqan::hibf::bit_vector.

Parameters

bit_vector

The seqan::hibf::bit_vector.

Precondition

counting_vector.size() >= bit_vector.size() and either:

• bit_vector.size() % 64 == 0

or

• counting_vector.capacity() >= seqan::hibf::next_multiple_of_64(bit_vector.size()) and
  • ∀ bit ∈ [bit_vector.size(), bit_vector.capacity()) : bit_vector[bit] == 0
    In practive, this condition might be violated by setting bits in a bit_vector and then shrinking it via resize().

Example

// SPDX-FileCopyrightText: 2006-2025, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <cstdint> // for uint16_t
 
#include <hibf/interleaved_bloom_filter.hpp> // for interleaved_bloom_filter, bin_index, bin_count, bin_size
#include <hibf/misc/counting_vector.hpp>     // for counting_vector
#include <hibf/misc/print.hpp>               // for print, print_t
 
int main()
{
    seqan::hibf::interleaved_bloom_filter ibf{seqan::hibf::bin_count{12u}, seqan::hibf::bin_size{8192u}};
    ibf.emplace(126, seqan::hibf::bin_index{0u});
    ibf.emplace(126, seqan::hibf::bin_index{3u});
    ibf.emplace(126, seqan::hibf::bin_index{9u});
    ibf.emplace(712, seqan::hibf::bin_index{3u});
    ibf.emplace(237, seqan::hibf::bin_index{9u});
 
    // The counting_vector must be at least as big as the number of bins.
    seqan::hibf::counting_vector<uint16_t> counts(12, 0);
 
    auto agent = ibf.membership_agent();
 
    counts += agent.bulk_contains(712); // `counts` contains the number of occurrences of 712 in each bin.
    seqan::hibf::print(counts);         // prints [0,0,0,1,0,0,0,0,0,0,0,0]
 
    counts += agent.bulk_contains(237); // `counts` contains the number of occurrences of 712 and 237 in each bin.
    seqan::hibf::print(counts);         // prints [0,0,0,1,0,0,0,0,0,1,0,0]
 
    counts += agent.bulk_contains(126); // `counts` contains the number of occurrences of 712, 237 and 126 in each bin.
    seqan::hibf::print(counts);         // prints [1,0,0,2,0,0,0,0,0,2,0,0]
 
    counts += counts;           // multiple counts can also be added together
    seqan::hibf::print(counts); // prints [2,0,0,4,0,0,0,0,0,4,0,0]
}

operator-=() [1/2]

template<std::integral value_t>

counting_vector & seqan::hibf::counting_vector< value_t >::operator-= ( bit_vector const & bit_vector )

inline

Bin-wise subtracts the bits of a seqan::hibf::bit_vector.

Parameters

bit_vector

The seqan::hibf::bit_vector.

Precondition

counting_vector.size() >= bit_vector.size() and either:

• bit_vector.size() % 64 == 0

or

• counting_vector.capacity() >= seqan::hibf::next_multiple_of_64(bit_vector.size()) and
  • ∀ bit ∈ [bit_vector.size(), bit_vector.capacity()) : bit_vector[bit] == 0
    In practive, this condition might be violated by setting bits in a bit_vector and then shrinking it via resize().

operator+=() [2/2]

template<std::integral value_t>

counting_vector & seqan::hibf::counting_vector< value_t >::operator+= ( counting_vector< value_t > const & rhs )

inline

Bin-wise addition of two seqan::hibf::counting_vectors.

Parameters

rhs	The other seqan::hibf::counting_vector.

Precondition

counting_vector.size() >= rhs.size()

Example

// SPDX-FileCopyrightText: 2006-2025, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <cstdint> // for uint16_t
 
#include <hibf/interleaved_bloom_filter.hpp> // for interleaved_bloom_filter, bin_index, bin_count, bin_size
#include <hibf/misc/counting_vector.hpp>     // for counting_vector
#include <hibf/misc/print.hpp>               // for print, print_t
 
int main()
{
    seqan::hibf::interleaved_bloom_filter ibf{seqan::hibf::bin_count{12u}, seqan::hibf::bin_size{8192u}};
    ibf.emplace(126, seqan::hibf::bin_index{0u});
    ibf.emplace(126, seqan::hibf::bin_index{3u});
    ibf.emplace(126, seqan::hibf::bin_index{9u});
    ibf.emplace(712, seqan::hibf::bin_index{3u});
    ibf.emplace(237, seqan::hibf::bin_index{9u});
 
    // The counting_vector must be at least as big as the number of bins.
    seqan::hibf::counting_vector<uint16_t> counts(12, 0);
 
    auto agent = ibf.membership_agent();
 
    counts += agent.bulk_contains(712); // `counts` contains the number of occurrences of 712 in each bin.
    seqan::hibf::print(counts);         // prints [0,0,0,1,0,0,0,0,0,0,0,0]
 
    counts += agent.bulk_contains(237); // `counts` contains the number of occurrences of 712 and 237 in each bin.
    seqan::hibf::print(counts);         // prints [0,0,0,1,0,0,0,0,0,1,0,0]
 
    counts += agent.bulk_contains(126); // `counts` contains the number of occurrences of 712, 237 and 126 in each bin.
    seqan::hibf::print(counts);         // prints [1,0,0,2,0,0,0,0,0,2,0,0]
 
    counts += counts;           // multiple counts can also be added together
    seqan::hibf::print(counts); // prints [2,0,0,4,0,0,0,0,0,4,0,0]
}

operator-=() [2/2]

template<std::integral value_t>

counting_vector & seqan::hibf::counting_vector< value_t >::operator-= ( counting_vector< value_t > const & rhs )

inline

Bin-wise subtraction of two seqan::hibf::counting_vectors.

Parameters

rhs	The other seqan::hibf::counting_vector.

Precondition

counting_vector.size() >= rhs.size()

---

The documentation for this class was generated from the following file:

• counting_vector.hpp