bitstring Class Reference

Non-template and faster implementation of std::bitset. More...

#include <bitstring.h>

Collaboration diagram for bitstring:

Classes
class	reference

Public Types
typedef unsigned long	_ul

Public Member Functions
	bitstring (size_t length)
	bitstring (const bitstring &b)
	~bitstring ()
_ul *	getword_atPos (size_t pos)
_ul *	getword_atIdx (size_t index)
size_t	size ()
size_t	nb_words ()
bool	at (size_t word, unsigned long bitmask)
reference	operator[] (size_t pos)
bool	operator[] (size_t n) const
bitstring &	operator= (const bitstring &b)
bitstring &	operator&= (const bitstring &x)
bitstring &	operator|= (const bitstring &x)
bitstring &	operator^= (const bitstring &x)
bitstring	operator~ (void)
bitstring	operator& (const bitstring &x)
bitstring	operator| (const bitstring &x)
bitstring	operator^ (const bitstring &x)
unsigned int	local_popcountl (_ul wd)
	Counts number of one's in string using a bit table count. More...
unsigned int	count ()
	Count number of set bits. More...
void	set (size_t n)
	Set a bit to 1. More...
void	flip (size_t n)
	Flip the bit at n. More...
void	set_data (_ul *srce, size_t nbwrd)
	Copy bits from an array of unsigned long words. More...
void	reset ()
	Set all bits to 0. More...
void	copy (const bitstring &b)
	Unchecked copy, assumes we have sames sizes. More...
void	copy (const bitstring &b, size_t word_pos)
	Copy one word. More...
void	copy (const bitstring &b, size_t from, size_t to)

Private Attributes
size_t	_size
size_t	_words
_ul *	_data

Static Private Attributes
static unsigned char	_bit_count [256]

Friends
class	reference

Detailed Description

Non-template and faster implementation of std::bitset.

Member Typedef Documentation

_ul

typedef unsigned long bitstring::_ul

Constructor & Destructor Documentation

bitstring() [1/2]

bitstring::bitstring ( size_t  length )

inline

  : _size(length), _words( BITSET_WORDS(length) ), _data(0)
  {
    _data = new _ul [_words];
    memset(_data, 0, _words * sizeof(_ul));
  }

References _data, and _words.

bitstring() [2/2]

bitstring::bitstring ( const bitstring &  b )

inline

  : _size(b._size), _words(b._words), _data(0)
  {
    _data = new _ul [_words];
    memcpy(_data, b._data, _words * sizeof(_ul));
  }

References _data, and _words.

~bitstring()

bitstring::~bitstring ( )

inline

{if(_data != NULL) delete [] _data;}

References _data.

Member Function Documentation

at()

bool bitstring::at ( size_t  word, unsigned long  bitmask  )

inline

  {
    return static_cast<bool>( _data[ word ] & bitmask );
  }

References _data.

copy() [1/3]

void bitstring::copy ( const bitstring &  b )

inline

Unchecked copy, assumes we have sames sizes.

  { memcpy(_data, b._data, _words * sizeof(_ul)); }

References _data, and _words.

Referenced by TProtoBDMI::inherit(), TProtoDeletMutations_bitstring::inherit_low(), TT_BDMI::operator=(), TTDeletMutations_bitstring::operator=(), TT_BDMI::set_sequence(), and TTDeletMutations_bitstring::set_sequence().

Here is the caller graph for this function:

copy() [2/3]

void bitstring::copy ( const bitstring &  b, size_t  from, size_t  to  )

inline

  {
    assert(to <= _size);
    
    size_t start_w, end_w, start_l, end_l;
    _ul mask, tmpl;
    
    start_w = from / BITS_PER_WORD;
    end_w = to / BITS_PER_WORD;
    
    start_l = from % BITS_PER_WORD;
    end_l = to % BITS_PER_WORD;
    
    if(start_w != end_w) {
      //copy wihtin first word:
      mask =  (MASK << start_l); 
      
      _data[ start_w ]   &= ~mask;
      tmpl = b._data[ start_w ] & mask;
      
      _data[ start_w ] |= tmpl;
      
      //copy words in-between:
      size_t k = start_w + 1;
      
      memcpy(&_data[k], &b._data[k], (end_w - k)*sizeof(_ul));
      
//      for(size_t k = start_w + 1; k < end_w; ++k) {
//        
//        _data[ k ] = b._data[ k ];
//        
//      }
      //copy within last word:
      mask =  (MASK >> (BITS_PER_WORD - end_l) ); 
      
      _data[ end_w ]   &= ~mask;;
      tmpl = b._data[ end_w ] & mask;
      
      _data[ end_w ] |= tmpl;
      
    } else {
      //bits to copy are within a word:
      mask =  (MASK << start_l) & (MASK >> (BITS_PER_WORD - end_l) );
      
      _data[ start_w ] &= ~mask;
      tmpl = b._data[ start_w ] & mask;
      
      _data[ start_w ] |= tmpl;
      
    }
    
  }

References _data, _size, BITS_PER_WORD, and MASK.

copy() [3/3]

void bitstring::copy ( const bitstring &  b, size_t  word_pos  )

inline

Copy one word.

  { _data[ word_pos ] = b._data[ word_pos ]; }

References _data.

count()

unsigned int bitstring::count ( )

inline

Count number of set bits.

  {
    unsigned int cnt = 0;
    
    for(size_t i = 0; i < _words; i++)
      cnt += local_popcountl(_data[i]);
    
    return cnt;
  }

References _data, _words, and local_popcountl().

Referenced by TTDeletMutations_bitstring::set_nb_hmz_mutations(), TTDeletMutations_bitstring::set_nb_htz_mutations(), and TTDeletMutations_bitstring::set_nb_mutations().

Here is the caller graph for this function:

flip()

void bitstring::flip ( size_t  n )

inline

Flip the bit at n.

{_data[n / BITS_PER_WORD] ^= (1UL << (n % BITS_PER_WORD));}

References _data, and BITS_PER_WORD.

Referenced by TT_BDMI::mutate_diplo(), TT_BDMI::mutate_haplo(), and TTDeletMutations_bitstring::mutate_noredraw().

Here is the caller graph for this function:

getword_atIdx()

_ul * bitstring::getword_atIdx ( size_t  index )

inline

  { return &_data[ index ]; }

References _data.

Referenced by TT_BDMI::store_data(), and TTDeletMutations_bitstring::store_data().

Here is the caller graph for this function:

getword_atPos()

_ul * bitstring::getword_atPos ( size_t  pos )

inline

  { return &_data[ pos / BITS_PER_WORD ]; }

References _data, and BITS_PER_WORD.

Referenced by bitstring::reference::reference().

Here is the caller graph for this function:

local_popcountl()

unsigned int bitstring::local_popcountl ( _ul  wd )

inline

Counts number of one's in string using a bit table count.

  {
    unsigned char* c = (unsigned char*)&wd;
    unsigned short cnt = 0;
    
    for(unsigned int i = 0; i < sizeof(_ul); i++)
      cnt += _bit_count[ (unsigned int)c[i] ];
    
    return (unsigned int) cnt;
  }

References _bit_count.

Referenced by count().

Here is the caller graph for this function:

nb_words()

size_t bitstring::nb_words ( )

inline

{return _words;}

References _words.

Referenced by TT_BDMI::retrieve_data(), TTDeletMutations_bitstring::retrieve_data(), TT_BDMI::store_data(), and TTDeletMutations_bitstring::store_data().

Here is the caller graph for this function:

operator&()

bitstring bitstring::operator& ( const bitstring &  x )

inline

  {
    bitstring result(*this);
    result &= x;
    return result;
  }

operator&=()

bitstring & bitstring::operator&= ( const bitstring &  x )

inline

  {
    for (size_t i = 0; i < _words; i++)
      _data[i] &= x._data[i];
    return *this;
  }

References _data, and _words.

operator=()

bitstring & bitstring::operator= ( const bitstring &  b )

inline

  {
    _size = b._size;
    _words = b._words;
    if(_data != NULL) delete [] _data;
    _data = new _ul [_words];
    memcpy(_data, b._data, _words * sizeof(_ul));
    return *this;
  }

References _data, _size, and _words.

operator[]() [1/2]

bool bitstring::operator[] ( size_t  n ) const

inline

  { return static_cast<bool>( _data[ n / BITS_PER_WORD ] & ( 1UL << ( n % BITS_PER_WORD ) ) ); }

References _data, and BITS_PER_WORD.

operator[]() [2/2]

reference bitstring::operator[] ( size_t  pos )

inline

  { return reference(*this, pos); }

operator^()

bitstring bitstring::operator^ ( const bitstring &  x )

inline

  {
    bitstring result(*this);
    result ^= x;
    return result;
  }

operator^=()

bitstring & bitstring::operator^= ( const bitstring &  x )

inline

  {
    for (size_t i = 0; i < _words; i++)
      _data[i] ^= x._data[i];
    return *this;
  }

References _data, and _words.

operator|()

bitstring bitstring::operator| ( const bitstring &  x )

inline

  {
    bitstring result(*this);
    result |= x;
    return result;
  }

operator|=()

bitstring & bitstring::operator|= ( const bitstring &  x )

inline

  {
    for (size_t i = 0; i < _words; i++)
      _data[i] |= x._data[i];
    return *this;
  }

References _data, and _words.

operator~()

bitstring bitstring::operator~ ( void  )

inline

  {
    for (size_t i = 0; i < _words; i++)
      _data[i] = ~(_data[i]);
    return *this;
  }

References _data, and _words.

reset()

void bitstring::reset ( )

inline

Set all bits to 0.

  { for(unsigned int i = 0; i < _words; i++) _data[i] = 0UL; }

References _data, and _words.

Referenced by TTDeletMutBitstrFH::FHread(), TT_BDMI::init_sequence(), TTDeletMutations_bitstring::init_sequence(), and TTNeutralGenesFH::write_PLINK_BED().

Here is the caller graph for this function:

set()

void bitstring::set ( size_t  n )

inline

Set a bit to 1.

{_data[n / BITS_PER_WORD] |= (1UL << (n % BITS_PER_WORD));}

References _data, and BITS_PER_WORD.

Referenced by TTDeletMutBitstrFH::FHread(), TT_BDMI::init_sequence(), TTDeletMutations_bitstring::init_sequence(), TTDeletMutations_bitstring::mutate_noredraw(), TTDeletMutations_bitstring::mutate_noredraw_noBackMutation(), TTDeletMutations_bitstring::mutate_redraw(), and TTDeletMutations_bitstring::set_allele_value().

Here is the caller graph for this function:

set_data()

void bitstring::set_data ( _ul *  srce, size_t  nbwrd  )

inline

Copy bits from an array of unsigned long words.

  { 
    //    if(nbwrd != _words) { 
    //      std::cerr<<"bitstring::set_data: different sizes in memcpy!!\n";
    //      exit(1);
    //      }
    assert(nbwrd == _words);
    memcpy(_data, srce, nbwrd * sizeof(_ul));
  }

References _data, and _words.

Referenced by TT_BDMI::retrieve_data(), and TTDeletMutations_bitstring::retrieve_data().

Here is the caller graph for this function:

size()

size_t bitstring::size ( )

inline

{return _size;}

References _size.

Friends And Related Function Documentation

reference

friend class reference

friend

Member Data Documentation

_bit_count

unsigned char bitstring::_bit_count

staticprivate

Referenced by local_popcountl().

_data

_ul* bitstring::_data

private

Referenced by at(), bitstring(), copy(), count(), flip(), getword_atIdx(), getword_atPos(), operator&=(), operator=(), operator[](), operator^=(), operator|=(), operator~(), reset(), set(), set_data(), and ~bitstring().

_size

size_t bitstring::_size

private

Referenced by copy(), operator=(), and size().

_words

size_t bitstring::_words

private

Referenced by bitstring(), copy(), count(), nb_words(), operator&=(), operator=(), operator^=(), operator|=(), operator~(), reset(), and set_data().

---

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

• bitstring.h
• bitstring.cc