BitMagic-C++
svsample06.cpp

Search/scan for elements in unordered, non-unique sparse vector.

Search/scan for elements in unordered, non-unique sparse vector

See also
bm::sparse_vector<>::const_iterator
bm::sparse_vector<>::back_insert_iterator
bm::sparse_vector_scanner
/*
Copyright(c) 2002-2017 Anatoliy Kuznetsov(anatoliy_kuznetsov at yahoo.com)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
For more information please visit: http://bitmagic.io
*/
/** \example svsample06.cpp
Search/scan for elements in unordered, non-unique sparse vector
\sa bm::sparse_vector<>::const_iterator
\sa bm::sparse_vector<>::back_insert_iterator
\sa bm::sparse_vector_scanner
*/
/*! \file svsample06.cpp
\brief Example: sparse_vector<> scan search (non-ordered set functionality)
*/
#include <iostream>
#include <vector>
#include <chrono>
#include <algorithm>
#include <random>
#include <stdexcept>
#include "bm.h"
#include "bmsparsevec.h"
#include "bmtimer.h"
using namespace std;
// ----------------------------------------------------
// Global parameters and types
// ----------------------------------------------------
const unsigned value_max = 1250000; // range of variants of events [0..max]
const unsigned test_size = 250000000; // vector size to generate
// -------------------------------------------
// Random generator
// -------------------------------------------
std::random_device rand_dev;
std::mt19937 gen(rand_dev());
std::uniform_int_distribution<> rand_dis(1, value_max); // generate uniform numebrs for [1, vector_max]
// timing storage for benchmarking
// Function to generate test vector set with some NULL values stored as a
// separate bit-bector
//
static
void generate_test_set(std::vector<unsigned>& vect,
bm::bvector<>& bv_null,
{
// back insert iterator is faster than random element access for sparse vector
//
vect.resize(test_size);
bv_null.reset();
for (unsigned i = 0; i < test_size; ++i)
{
unsigned v = unsigned(rand_dis(gen));
vect[i] = v;
bv_null[i] = true; // not NULL(assigned) element
*bi = v; // push back an element to sparse vector
if (i % 64 == 0)
{
bi.add_null(5); // add 5 unassigned elements using back inserter
i += 5; // insert a small NULL plate (unassigned values)
}
} // for
}
// plain scan in std::vector<>, matching values are indexed
// in result bit-vector (subset projection)
// values are added, so multiple calls result in subset addition
static
void vector_search(const std::vector<unsigned>& vect,
const bm::bvector<>& bv_null,
unsigned value,
bm::bvector<>& bv_res)
{
bv_res.init(); // always use init() if set_bit_no_check()
for (size_t i = 0; i < vect.size(); ++i)
{
if (vect[i] == value)
} // for
bv_res &= bv_null; // correct results to only include non-NULL values
}
inline
{
cout << "( count = " << bv.count() << ")" << ": [";
for (; en.valid(); ++en)
cout << *en << ", ";
cout << "]" << endl;
}
int main(void)
{
try
{
// First, lets run, simple (printable) search case
//
{
sv.set(2, 25);
sv.set(3, 35);
sv.set(7, 75);
sv.set(1000, 2000);
sv.set(256, 2001);
sv.set(77, 25);
bm::bvector<> bv_found; // search results vector
scanner.find_eq(sv, 25, bv_found); // seach for all values == 25
print_bvector(bv_found); // print results
scanner.invert(sv, bv_found); // invert search results to NOT EQ
print_bvector(bv_found); // print all != 25
}
std::vector<unsigned> vect;
bm::bvector<> bv_null;
{
bm::chrono_taker tt1("0. test set generate ", 1, &timing_map);
generate_test_set(vect, bv_null, sv);
}
unsigned search_repeats = 500;
// generate a search vector for benchmarking
//
std::vector<unsigned> search_vect;
{
bm::bvector<> bv_tmp;
search_vect.reserve(search_repeats);
for (unsigned i = 0; i < search_repeats;)
{
if (!bv_tmp.test(idx)) // check if number is unique
{
search_vect.push_back(idx);
bv_tmp[idx] = 1;
++i;
}
}
}
// run benchmarks
//
bm::bvector<> bv_res1;
bm::bvector<> bv_res2;
bm::bvector<> bv_res3;
{
bm::chrono_taker tt1("1. std::vector<> scan ", search_repeats, &timing_map);
for (unsigned i = 0; i < search_repeats; ++i)
{
unsigned vs = search_vect[i];
vector_search(vect, bv_null, vs, bv_res1);
} // for
}
{
bm::chrono_taker tt1("2. sparse_vector<> scan ", search_repeats, &timing_map);
scanner.find_eq(sv, search_vect.begin(), search_vect.end(), bv_res2);
}
// check jus in case if results look correct
if (bv_res1.compare(bv_res2) != 0)
{
std::cerr << "2. Search result mismatch!" << std::endl;
}
{
bv_res3.init(); // always init before calling "set_bit_no_check()"
bm::chrono_taker tt1("3. sparse_vector<>::const_iterator search ", search_repeats, &timing_map);
// prepare a unique search set
bm::combine_or(bv_search, search_vect.begin(), search_vect.end());
for (; it != it_end; ++it)
{
unsigned v = *it;
if (bv_search.test(v))
{
bv_res3.set_bit_no_check(it.pos());
}
} // for
}
// paranoiya check
if (bv_res1.compare(bv_res3) != 0)
{
std::cerr << "3. Search result mismatch!" << std::endl;
}
}
catch(std::exception& ex)
{
std::cerr << ex.what() << std::endl;
return 1;
}
return 0;
}
Compressed bit-vector bvector<> container, set algebraic methods, traversal iterators.
Sparse constainer sparse_vector<> for integer types using bit-transposition transform.
Algorithms for bm::sparse_vector.
Timing utilities for benchmarking (internal)
Constant iterator designed to enumerate "ON" bits.
Definition bm.h:600
bool valid() const BMNOEXCEPT
Checks if iterator is still valid.
Definition bm.h:280
Bitvector Bit-vector container with runtime compression of bits.
Definition bm.h:108
bvector< Alloc > & reset()
Clears every bit in the bitvector.
Definition bm.h:1225
bool test(size_type n) const BMNOEXCEPT
returns true if bit n is set and false is bit n is 0.
Definition bm.h:1440
size_type count() const BMNOEXCEPT
population cout (count of ON bits)
Definition bm.h:2194
enumerator first() const
Returns enumerator pointing on the first non-zero bit.
Definition bm.h:1770
void init()
Explicit post-construction initialization.
Definition bm.h:2123
int compare(const bvector< Alloc > &bvect) const BMNOEXCEPT
Lexicographical comparison with a bitvector.
Definition bm.h:3159
void set_bit_no_check(size_type n)
Set bit without checking preconditions (size, etc)
Definition bm.h:3468
Utility class to collect performance measurements and statistics.
Definition bmtimer.h:40
static void print_duration_map(const duration_map_type &dmap, format fmt=ct_time)
Definition bmtimer.h:127
std::map< std::string, statistics > duration_map_type
test name to duration map
Definition bmtimer.h:65
algorithms for sparse_vector scan/search
void invert(const SV &sv, typename SV::bvector_type &bv_out)
invert search result ("EQ" to "not EQ")
void find_eq(const SV &sv, typename SV::value_type value, typename SV::bvector_type &bv_out)
find all sparse vector elements EQ to search value
sparse vector with runtime compression using bit transposition method
Definition bmsparsevec.h:82
void set(size_type idx, value_type v)
set specified element with bounds checking and automatic resize
const_iterator end() const BMNOEXCEPT
Provide const iterator access to the end
back_insert_iterator get_back_inserter()
Provide back insert iterator Back insert iterator implements buffered insertion, which is faster,...
const_iterator begin() const BMNOEXCEPT
Provide const iterator access to container content
@ use_null
support "non-assigned" or "NULL" logic
Definition bmconst.h:215
@ BM_GAP
GAP compression is ON.
Definition bmconst.h:144
void combine_or(BV &bv, It first, It last)
OR Combine bitvector and the iterable sequence.
unsigned int id_t
Definition bmconst.h:37
std::random_device rand_dev
Definition sample11.cpp:49
bm::chrono_taker::duration_map_type timing_map
Definition sample11.cpp:44
std::uniform_int_distribution rand_dis(1, int(vector_max))
std::mt19937 gen(rand_dev())
int main(void)
Definition sample1.cpp:38
static void print_bvector(const bm::bvector<> &bv)
Definition sample2.cpp:34
static void vector_search(const std::vector< unsigned > &vect, const bm::bvector<> &bv_null, unsigned value, bm::bvector<> &bv_res)
static void generate_test_set(std::vector< unsigned > &vect, bm::bvector<> &bv_null, sparse_vector_u32 &sv)
const unsigned test_size
Definition xsample02.cpp:55
bm::sparse_vector< unsigned, bm::bvector<> > sparse_vector_u32
Definition xsample02.cpp:66
const unsigned value_max
Definition xsample02.cpp:54