text: /*
  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 "bmsparsevec.h"
  #include "bmsparsevec_algo.h"
  #include "bmtimer.h"
  
  
  using namespace std;
  
  typedef bm::sparse_vector<bm::id_t, bm::bvector<> > sparse_vector_u32;
  
  
  // ----------------------------------------------------
  // 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
  bm::chrono_taker::duration_map_type  timing_map;
  
  
  
  // 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,
                          sparse_vector_u32&     sv)
  {
      // back insert iterator is faster than random element access for sparse vector
      //
      sparse_vector_u32::back_insert_iterator bi(sv.get_back_inserter());
  
      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)
              bv_res.set_bit_no_check((bm::id_t)i);
      } // for
      bv_res &= bv_null; // correct results to only include non-NULL values
  }
  
  
  inline
  void print_bvector(const bm::bvector<>& bv)
  {
      cout << "( count = " << bv.count() << ")" << ": [";
      
      bm::bvector<>::enumerator en = bv.first();
      for (; en.valid(); ++en)
          cout << *en << ", ";
      cout << "]" << endl;
  }
  
  
  int main(void)
  {
      try
      {
          // First, lets run, simple (printable) search case
          //
          {
              sparse_vector_u32 sv(bm::use_null);
              
              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
              
              bm::sparse_vector_scanner<sparse_vector_u32> scanner; // scanner class
              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;
          sparse_vector_u32 sv(bm::use_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;)
              {
                  bm::id_t idx = bm::id_t(rand_dis(gen));
                  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);
  
              bm::sparse_vector_scanner<sparse_vector_u32> scanner;
              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::bvector<> bv_search(bm::BM_GAP);
              bm::combine_or(bv_search, search_vect.begin(), search_vect.end());
  
              sparse_vector_u32::const_iterator it = sv.begin();
              sparse_vector_u32::const_iterator it_end = sv.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;
          }
  
          
          bm::chrono_taker::print_duration_map(timing_map, bm::chrono_taker::ct_ops_per_sec);
  
      }
      catch(std::exception& ex)
      {
          std::cerr << ex.what() << std::endl;
          return 1;
      }
  
      return 0;
  }
  
  