bitvec.h

Go to the documentation of this file.

/**********************************************************************
bitvec.h - Vector of bits.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_BITVEC_H
#define OB_BITVEC_H

#include <openbabel/babelconfig.h>

#include <vector>
#include <string>

#ifndef USE_64BIT_INTEGER
// For 32-bit architecture
#define SETWORD 32
// SETWORD = 2 ^ WORDROLL
#define WORDROLL 5
// WORDMASK = SETWORD - 1
#define WORDMASK 31
#else
// For 64-bit architecture
#define SETWORD 64
// SETWORD = 2 ^ WORDROLL
#define WORDROLL 6
// WORDMASK = SETWORD - 1
#define WORDMASK 63
#endif // 64 bit

#define WORDSIZE_OF_BITSIZE( bit_size ) ( ( bit_size >> WORDROLL ) + (( bit_size & WORDMASK ) ? 1 : 0) )

#ifndef STARTWORDS
#define STARTWORDS 10
#endif // STARTWORDS

namespace OpenBabel
  {

  class OBERROR OBBitVec
    {
    public:
          typedef std::vector<unsigned> word_vector;

        private:
      size_t _size; //was unsigned
      word_vector       _set;

    public:

      OBBitVec()
          :_set(STARTWORDS, 0)
        { _size = _set.size(); }

      OBBitVec(unsigned size_in_bits)
          :_set(WORDSIZE_OF_BITSIZE(size_in_bits), 0)
        { _size = _set.size(); }

      OBBitVec(const OBBitVec & bv)
          :_size(0)
                { (*this) = bv; }
      void SetBitOn(unsigned bit_offset);
      void SetBitOff(unsigned bit_offset);
      void SetRangeOn(unsigned lo_bit_offset, unsigned hi_bit_offset);
      void SetRangeOff(unsigned lo_bit_offset, unsigned hi_bit_offset);
      void Fold(unsigned new_bit_size);

      int FirstBit(unsigned bit_offset = 0) const
        {
          return (BitIsSet(bit_offset) ? 0  : NextBit(bit_offset));
        }
      int NextBit(int last_bit_offset) const;
      int EndBit() const {  return -1; }
      size_t GetSize() const    { return(_size);    }
      unsigned CountBits() const;

      bool Empty() const   { return(IsEmpty()); }
      bool IsEmpty() const;

      bool Resize(unsigned size_in_bits)
                {
                return ResizeWords( WORDSIZE_OF_BITSIZE(size_in_bits) );
                }

          bool ResizeWords(unsigned size_in_words)
                {
                if (size_in_words <= _size)
                  return false;
                _set.resize(size_in_words, 0); // increase the vector with zeroed bits
                _size = _set.size();
                return true;
                }

      bool BitIsSet(unsigned bit_offset) const
        {
                  bool rtn = false;
                  unsigned word_offset = bit_offset >> WORDROLL;
                  if (word_offset < GetSize())
                        {
                          bit_offset &= WORDMASK;
                          rtn = (( _set[word_offset] >> bit_offset ) & 1);
                        }
          return rtn;
        }
      bool BitIsOn(int bit_offset) const
        { return BitIsSet((unsigned)bit_offset); }

          void FromVecInt(const std::vector<int> & bit_offsets);
          void FromString(const std::string & line, int bits);
          void ToVecInt(std::vector<int> & bit_offsets) const;
      void Clear();

      void Negate()
        {
                  for (word_vector::iterator wx = _set.begin(), wy = _set.end(); wx != wy; ++wx)
                    * wx = ~(* wx);
        }

      void GetWords(word_vector & vec)
        {
                vec.insert(vec.end(), _set.begin(),_set.end());
        }

      OBBitVec & operator= (const OBBitVec & bv);
      OBBitVec & operator&= (const OBBitVec & bv);
      OBBitVec & operator|= (const OBBitVec & bv);

      OBBitVec & operator|= (int bit_offset)
        {
          SetBitOn(bit_offset);
          return(*this);
        }
      OBBitVec & operator^= (const OBBitVec & bv);
      OBBitVec & operator-= (const OBBitVec & bv);
      OBBitVec & operator+= (const OBBitVec & bv);

      bool operator[] (int bit_offset) const
        { return BitIsSet(bit_offset); }

      friend OBERROR OBBitVec operator| (const OBBitVec & bv1, const OBBitVec & bv2);
      friend OBERROR OBBitVec operator& (const OBBitVec & bv1,const OBBitVec & bv2);
      friend OBERROR OBBitVec operator^ (const OBBitVec & bv1,const OBBitVec & bv2);
      friend OBERROR OBBitVec operator- (const OBBitVec & bv1,const OBBitVec & bv2);
      friend OBERROR bool operator== (const OBBitVec & bv1,const OBBitVec & bv2);
      friend OBERROR bool operator< (const OBBitVec & bv1, const OBBitVec & bv2);

      friend OBERROR std::istream& operator>> ( std::istream & is, OBBitVec & bv );
      friend OBERROR std::ostream& operator<< ( std::ostream & os, const OBBitVec & bv ) ;
    };

  OBERROR double Tanimoto(const OBBitVec & bv1, const OBBitVec & bv2);

  } // end namespace OpenBabel

#endif // OB_BITVEC_H