#include <bit_vector_ranking.hpp>

Inheritance diagram for jubatus::core::storage::bit_vector_base< bit_base >:

Collaboration diagram for jubatus::core::storage::bit_vector_base< bit_base >:

Public Member Functions
void	alloc_memory ()

size_t	bit_count () const

size_t	bit_num () const

	bit_vector_base ()

	bit_vector_base (const bit_base *bits, size_t bit_num)

	bit_vector_base (int bit_num)

	bit_vector_base (const bit_vector_base &orig)

uint64_t	calc_hamming_distance (const bit_vector_base &bv) const

uint64_t	calc_hamming_similarity (const bit_vector_base &bv) const

void	clear ()

void	clear_bit (size_t pos)

void	debug_print (std::ostream &os) const

bool	get_bit (size_t pos) const

bool	is_empty () const

template<typename Buffer >
void	msgpack_pack (msgpack::packer< Buffer > &packer) const

void	msgpack_unpack (msgpack::object o)

bool	operator!= (const bit_vector_base &rhs) const

bit_vector_base &	operator= (const bit_vector_base &orig)

bool	operator== (const bit_vector_base &rhs) const

template<typename packable >
void	pack (packable &buffer) const

bit_base *	raw_data_unsafe ()

const bit_base *	raw_data_unsafe () const

void	resize_and_clear (uint64_t bit_num)

void	reverse_bit (size_t pos)

void	set_bit (size_t pos)

void	status (std::ostream &os) const

void	swap (bit_vector_base &x)

size_t	used_bytes () const

	~bit_vector_base ()

Static Public Member Functions
static size_t	memory_size (size_t bit_width)

Static Public Attributes
static const size_t	BASE_BITS = sizeof(bit_base) * 8

static const size_t	BLOCKSIZE = sizeof(bit_base)

Private Member Functions
void	duplicate (const bit_vector_base &orig)

bool	release ()

Private Attributes
size_t	bit_num_

bit_base *	bits_

bool	own_

Friends
std::ostream &	operator<< (std::ostream &os, const bit_vector_base &bv)

void	swap (bit_vector_base &l, bit_vector_base &r)

Detailed Description

template<typename bit_base>
struct jubatus::core::storage::bit_vector_base< bit_base >

Definition at line 27 of file bit_vector_ranking.hpp.

Constructor & Destructor Documentation

template<typename bit_base>

jubatus::core::storage::bit_vector_base< bit_base >::bit_vector_base ( )

inline

Definition at line 138 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::msgpack_unpack().

139 : bits_(NULL), bit_num_(0), own_(false) {

140 }

jubatus::core::storage::bit_vector_base::bits_

bit_base * bits_

Definition: bit_vector.hpp:429

jubatus::core::storage::bit_vector_base::own_

bool own_

Definition: bit_vector.hpp:431

jubatus::core::storage::bit_vector_base::bit_num_

size_t bit_num_

Definition: bit_vector.hpp:430

Here is the caller graph for this function:

template<typename bit_base>

jubatus::core::storage::bit_vector_base< bit_base >::bit_vector_base	(	const bit_base *	bits,
		size_t	bit_num
	)

inline

Definition at line 142 of file bit_vector.hpp.

       : bits_(NULL),
         bit_num_(bit_num),
         own_(false) {
     alloc_memory();
     memcpy(bits_, bits, used_bytes());
   }

template<typename bit_base>

jubatus::core::storage::bit_vector_base< bit_base >::bit_vector_base ( int bit_num )

inlineexplicit

Definition at line 150 of file bit_vector.hpp.

       : bits_(NULL),
         bit_num_(bit_num),
         own_(false) {
   }

template<typename bit_base>

jubatus::core::storage::bit_vector_base< bit_base >::bit_vector_base ( const bit_vector_base< bit_base > & orig )

inline

Definition at line 156 of file bit_vector.hpp.

       : bits_(NULL),
         bit_num_(orig.bit_num_),
         own_(false) {
     if (orig.bits_ == NULL) {
       return;
     }
     alloc_memory();
     memcpy(bits_, orig.bits_, used_bytes());
   }

template<typename bit_base>

jubatus::core::storage::bit_vector_base< bit_base >::~bit_vector_base ( )

inline

Definition at line 167 of file bit_vector.hpp.

                      {
     if (bits_ && own_) {
       release();
       return;
     }
   }

Member Function Documentation

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::alloc_memory ( )

inline

Definition at line 396 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::bit_vector_base(), jubatus::core::storage::bit_vector_base< uint64_t >::duplicate(), jubatus::core::storage::bit_vector_base< uint64_t >::operator=(), jubatus::core::storage::bit_vector_base< uint64_t >::reverse_bit(), and jubatus::core::storage::bit_vector_base< uint64_t >::set_bit().

                       {
     JUBATUS_ASSERT(!own_);
     bits_ = new bit_base[used_bytes()];
     own_ = true;
     memset(bits_, 0, used_bytes());
   }

Here is the caller graph for this function:

template<typename bit_base>

size_t jubatus::core::storage::bit_vector_base< bit_base >::bit_count ( ) const

inline

Definition at line 296 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::calc_hamming_distance(), and jubatus::core::storage::bit_vector_base< uint64_t >::is_empty().

                            {
     if (bits_ == NULL) {
       return 0;
     }
     size_t result = 0;
     for (int64_t i = (used_bytes() / sizeof(bit_base)) - 1; i >= 0; --i) {
       result += detail::bitcount(bits_[i]);
     }
     return result;
   }

Here is the caller graph for this function:

template<typename bit_base>

size_t jubatus::core::storage::bit_vector_base< bit_base >::bit_num ( ) const

inline

Definition at line 313 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::calc_hamming_distance(), jubatus::core::storage::bit_vector_base< uint64_t >::calc_hamming_similarity(), jubatus::core::storage::typed_column< bit_vector >::check_bit_vector_(), jubatus::core::storage::bit_vector_base< uint64_t >::msgpack_unpack(), jubatus::core::storage::bit_vector_base< uint64_t >::resize_and_clear(), and jubatus::core::storage::bit_index_storage::similar_row().

                          {
     return bit_num_;
   }

Here is the caller graph for this function:

template<typename bit_base>

uint64_t jubatus::core::storage::bit_vector_base< bit_base >::calc_hamming_distance ( const bit_vector_base< bit_base > & bv ) const

inline

Definition at line 276 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::calc_hamming_similarity().

                                                                   {
     if (bit_num() != bv.bit_num()) {
       throw bit_vector_unmatch_exception(
           "calc_hamming_similarity(): bit_vector length unmatch! " +
           jubatus::util::lang::lexical_cast<std::string>(bit_num()) + " with " +
           jubatus::util::lang::lexical_cast<std::string>(bv.bit_num()));
     }
     if (is_empty() && bv.is_empty()) {
       return 0;
     } else if (is_empty()) {
       return bv.bit_count();
     } else if (bv.is_empty()) {
       return bit_count();
     }
     size_t match_num = 0;
     for (size_t i = 0; i < used_bytes() / sizeof(bit_base); ++i) {
       match_num += detail::bitcount(bits_[i] ^ bv.bits_[i]);
     }
     return match_num;
   }

Here is the caller graph for this function:

template<typename bit_base>

uint64_t jubatus::core::storage::bit_vector_base< bit_base >::calc_hamming_similarity ( const bit_vector_base< bit_base > & bv ) const

inline

Definition at line 273 of file bit_vector.hpp.

Referenced by jubatus::core::storage::similar_row_one().

                                                                     {
     return bit_num() - calc_hamming_distance(bv);
   }

Here is the caller graph for this function:

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::clear ( )

inline

Definition at line 268 of file bit_vector.hpp.

                {
     for (size_t i = 0; i < bit_num_; ++i) {
       clear_bit(i);
     }
   }

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::clear_bit ( size_t pos )

inline

Definition at line 225 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::clear().

                              {
     if (bits_ == NULL) {
       return;
     }
     bits_[pos / BASE_BITS] &= ~(1LLU << (pos % BASE_BITS));
   }

Here is the caller graph for this function:

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::debug_print ( std::ostream & os ) const

inline

Definition at line 323 of file bit_vector.hpp.

                                          {
     if (bits_ == NULL) {
       os << "(unallocated)";
       return;
     }
     for (uint64_t i = 0; i < used_bytes() * 8; ++i) {
       if ((bits_[i / (sizeof(bit_base) * 8)] >> (i % (sizeof(bit_base) * 8))) &
           1LLU) {
         os << "1";
       } else {
         os << "0";
       }
     }
   }

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::duplicate ( const bit_vector_base< bit_base > & orig )

inlineprivate

Definition at line 415 of file bit_vector.hpp.

                                               {
     if (bit_num_ != orig.bit_num_) {
       throw bit_vector_unmatch_exception(
           "failed copy bit vector from " +
           jubatus::util::lang::lexical_cast<std::string>(orig.bit_num_) +
           " to " +
           jubatus::util::lang::lexical_cast<std::string>(bit_num_));
     }
     if (!own_) {
       alloc_memory();
     }
     memcpy(bits_, orig.bits_, used_bytes());
   }

template<typename bit_base>

bool jubatus::core::storage::bit_vector_base< bit_base >::get_bit ( size_t pos ) const

inline

Definition at line 258 of file bit_vector.hpp.

                                  {
     if (bits_ == NULL) {
       return false;
     }
     return bits_[pos / BASE_BITS] & (1LLU << (pos % BASE_BITS));
   }

template<typename bit_base>

bool jubatus::core::storage::bit_vector_base< bit_base >::is_empty ( ) const

inline

Definition at line 264 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::calc_hamming_distance(), and jubatus::core::storage::bit_vector_base< uint64_t >::operator==().

                         {
     return bit_count() == 0;
   }

Here is the caller graph for this function:

template<typename bit_base>

static size_t jubatus::core::storage::bit_vector_base< bit_base >::memory_size ( size_t bit_width )

inlinestatic

Definition at line 319 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::msgpack_unpack(), and jubatus::core::storage::bit_vector_base< uint64_t >::used_bytes().

                                               {
     return ((((bit_width + 7) / 8) + BLOCKSIZE - 1) / BLOCKSIZE) * BLOCKSIZE;
   }

Here is the caller graph for this function:

template<typename bit_base>

template<typename Buffer >

void jubatus::core::storage::bit_vector_base< bit_base >::msgpack_pack ( msgpack::packer< Buffer > & packer ) const

inline

Definition at line 355 of file bit_vector.hpp.

                                                          {
     packer.pack_array(2);
     packer.pack(static_cast<uint64_t>(bit_num_));
     packer.pack_raw(used_bytes());
     if (bits_) {
       const size_t n = used_bytes() / BLOCKSIZE;
       for (size_t i = 0; i < n; ++i) {
         char buf[BLOCKSIZE];
         common::write_big_endian(bits_[i], buf);
         packer.pack_raw_body(buf, BLOCKSIZE);
       }
     } else {
       const char c = 0;
       for (size_t i = 0; i < used_bytes(); ++i) {
         packer.pack_raw_body(&c, 1);
       }
     }
   }

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::msgpack_unpack ( msgpack::object o )

inline

Definition at line 373 of file bit_vector.hpp.

                                        {
     if (o.type != msgpack::type::ARRAY || o.via.array.size != 2) {
       throw msgpack::type_error();  // like MSGPACK_DEFINE
     }
     const msgpack::object* objs = o.via.array.ptr;
     const uint64_t bit_num = objs[0].as<uint64_t>();
     const msgpack::type::raw_ref data = objs[1].as<msgpack::type::raw_ref>();
     if (data.size != memory_size(bit_num)) {
       throw bit_vector_unmatch_exception(
           "msgpack_unpack(): invalid length of packed data: "
           "expected: " +
           jubatus::util::lang::lexical_cast<std::string>(bit_num_) +
           ", got: " +
           jubatus::util::lang::lexical_cast<std::string>(data.size));
     }
     std::vector<bit_base> buf;
     for (size_t i = 0; i < data.size; i += BLOCKSIZE) {
       buf.push_back(common::read_big_endian<bit_base>(&data.ptr[i]));
     }
     bit_vector_base(&buf[0], bit_num).swap(*this);
     JUBATUS_ASSERT(own_ || bits_ == NULL);
   }

template<typename bit_base>

bool jubatus::core::storage::bit_vector_base< bit_base >::operator!= ( const bit_vector_base< bit_base > & rhs ) const

inline

Definition at line 195 of file bit_vector.hpp.

                                                     {
     return !this->operator==(rhs);
   }

template<typename bit_base>

bit_vector_base& jubatus::core::storage::bit_vector_base< bit_base >::operator= ( const bit_vector_base< bit_base > & orig )

inline

Definition at line 200 of file bit_vector.hpp.

                                                           {
     if (&orig != this) {
       bit_num_ = orig.bit_num_;
       if (bits_ == NULL) {
         alloc_memory();
       }
       if (orig.bits_ == NULL) {
         memset(bits_, 0, used_bytes());
       } else {
         memcpy(bits_, orig.bits_, used_bytes());
       }
     }
     return *this;
   }

template<typename bit_base>

bool jubatus::core::storage::bit_vector_base< bit_base >::operator== ( const bit_vector_base< bit_base > & rhs ) const

inline

Definition at line 180 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::operator!=().

                                                     {
     if (bit_num_ != rhs.bit_num_) {
       return false;
     }
     if (is_empty() && rhs.is_empty()) {
       return true;
     }
     if (is_empty() && !rhs.is_empty()) {
       return false;
     }
     if (!is_empty() && rhs.is_empty()) {
       return false;
     }
     return memcmp(bits_, rhs.bits_, used_bytes()) == 0;
   }

Here is the caller graph for this function:

template<typename bit_base>

template<typename packable >

void jubatus::core::storage::bit_vector_base< bit_base >::pack ( packable & buffer ) const

inline

Definition at line 351 of file bit_vector.hpp.

                                     {
     msgpack::pack(buffer, *this);
   }

template<typename bit_base>

bit_base* jubatus::core::storage::bit_vector_base< bit_base >::raw_data_unsafe ( )

inline

Definition at line 307 of file bit_vector.hpp.

Referenced by jubatus::core::storage::typed_column< bit_vector >::insert(), jubatus::core::storage::typed_column< bit_vector >::push_back(), and jubatus::core::storage::typed_column< bit_vector >::update().

                               {
     return bits_;
   }

Here is the caller graph for this function:

template<typename bit_base>

const bit_base* jubatus::core::storage::bit_vector_base< bit_base >::raw_data_unsafe ( ) const

inline

Definition at line 310 of file bit_vector.hpp.

                                           {
     return bits_;
   }

template<typename bit_base>

bool jubatus::core::storage::bit_vector_base< bit_base >::release ( )

inlineprivate

Definition at line 404 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::resize_and_clear(), and jubatus::core::storage::bit_vector_base< uint64_t >::~bit_vector_base().

                  {
     if (bits_ && own_) {
       delete[] bits_;
       own_ = false;
       bits_ = NULL;
       return true;
     }
     return false;
   }

Here is the caller graph for this function:

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::resize_and_clear ( uint64_t bit_num )

inline

Definition at line 174 of file bit_vector.hpp.

Referenced by jubatus::core::recommender::set_bit_vector().

                                           {
     release();
     own_ = false;
     bit_num_ = bit_num;
   }

Here is the caller graph for this function:

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::reverse_bit ( size_t pos )

inline

Definition at line 244 of file bit_vector.hpp.

                                {
     if (bits_ == NULL) {
       alloc_memory();
     }
     if (bit_num_ < pos) {
       throw bit_vector_unmatch_exception(
           "reverse_bit(): invalid posison " +
           jubatus::util::lang::lexical_cast<std::string>(pos) +
           " for length: " +
           jubatus::util::lang::lexical_cast<std::string>(bit_num_));
     }
     bits_[pos / BASE_BITS] ^= (1LLU << (pos % BASE_BITS));
   }

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::set_bit ( size_t pos )

inline

Definition at line 231 of file bit_vector.hpp.

Referenced by jubatus::core::nearest_neighbor::binarize().

                            {
     if (bits_ == NULL) {
       alloc_memory();
     }
     if (static_cast<size_t>(bit_num_) < pos) {
       throw bit_vector_unmatch_exception(
           "set_bit(): invalid posison " +
           jubatus::util::lang::lexical_cast<std::string>(pos) +
           " for length: " +
           jubatus::util::lang::lexical_cast<std::string>(bit_num_));
     }
     bits_[pos / BASE_BITS] |= (1LLU << (pos % BASE_BITS));
   }

Here is the caller graph for this function:

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::status ( std::ostream & os ) const

inline

Definition at line 341 of file bit_vector.hpp.

                                     {
     os << "status():";
     if (bits_ == NULL) {
       os << "(unallocated)" << " owns_" << own_;
       return;
     }
     os << (own_ ? "[own]" : "[other]") << std::endl;
   }

template<typename bit_base>

void jubatus::core::storage::bit_vector_base< bit_base >::swap ( bit_vector_base< bit_base > & x )

inline

Definition at line 215 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::swap().

                                 {
     using std::swap;
     swap(bit_num_, x.bit_num_);
     swap(bits_, x.bits_);
     swap(own_, x.own_);
   }

Here is the caller graph for this function:

template<typename bit_base>

size_t jubatus::core::storage::bit_vector_base< bit_base >::used_bytes ( ) const

inline

Definition at line 316 of file bit_vector.hpp.

                             {
     return memory_size(bit_num_);
   }

Here is the caller graph for this function:

Friends And Related Function Documentation

template<typename bit_base>

std::ostream& operator<<	(	std::ostream &	os,
		const bit_vector_base< bit_base > &	bv
	)

friend

Definition at line 337 of file bit_vector.hpp.

                                                                            {
     bv.debug_print(os);
     return os;
   }

template<typename bit_base>

void swap	(	bit_vector_base< bit_base > &	l,
		bit_vector_base< bit_base > &	r
	)

friend

Definition at line 221 of file bit_vector.hpp.

                                                            {
     l.swap(r);
   }

Member Data Documentation

template<typename bit_base>

const size_t jubatus::core::storage::bit_vector_base< bit_base >::BASE_BITS = sizeof(bit_base) * 8

static

Definition at line 135 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::clear_bit(), jubatus::core::storage::bit_vector_base< uint64_t >::get_bit(), jubatus::core::storage::bit_vector_base< uint64_t >::reverse_bit(), and jubatus::core::storage::bit_vector_base< uint64_t >::set_bit().

template<typename bit_base>

size_t jubatus::core::storage::bit_vector_base< bit_base >::bit_num_

private

Definition at line 430 of file bit_vector.hpp.

template<typename bit_base>

bit_base* jubatus::core::storage::bit_vector_base< bit_base >::bits_

private

Definition at line 429 of file bit_vector.hpp.

template<typename bit_base>

const size_t jubatus::core::storage::bit_vector_base< bit_base >::BLOCKSIZE = sizeof(bit_base)

static

Definition at line 136 of file bit_vector.hpp.

Referenced by jubatus::core::storage::bit_vector_base< uint64_t >::memory_size(), jubatus::core::storage::bit_vector_base< uint64_t >::msgpack_pack(), and jubatus::core::storage::bit_vector_base< uint64_t >::msgpack_unpack().

template<typename bit_base>

bool jubatus::core::storage::bit_vector_base< bit_base >::own_

private

Definition at line 431 of file bit_vector.hpp.

The documentation for this struct was generated from the following files:

jubatus/core/nearest_neighbor/bit_vector_ranking.hpp
jubatus/core/storage/bit_vector.hpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename bit_base> struct jubatus::core::storage::bit_vector_base< bit_base >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename bit_base>
struct jubatus::core::storage::bit_vector_base< bit_base >