BitVector (version 1.4, 2008-April-18)		index
/home/kak/BitVector/BitVector-1.4/BitVector.py

    BitVector.py
 
    Version: 1.4
   
    Author: Avinash Kak (kak@purdue.edu)
 
    Date: 2008-April-18
 
    Download Version 1.4   gztar   bztar 

 
    View version 1.4 code in browser 

 

           

 

           

Switch to Version 1.4.1




Switch to Version 1.5


           

Switch to Version 1.5.1


 


           

 

    CHANGE LOG:


 

 

       Version 1.4:

 

           This version includes the following two upgrades: 

           1) code for slice assignment; and 2) A reset function 

           to reinitialize a previously constructed BitVector.  

           Additionally, the code was cleaned up with the help of 

           pychecker.

 

       Version 1.3.2:

 

           Fixed a potentially misleading documentation issue for

           the Windows users of the BitVector class.  If you are 

           writing an internally generated BitVector to a disk file, 

           you must open the file in the binary mode.  If you don't,

           the bit patterns that correspond to line breaks will be

           misinterpreted.  On a Windows machine in the text mode,

           the bit pattern 00001010 ('\n') will be written out

           to the disk as 0000110100001010 ('\r\n').

 

       Version 1.3.1:

 

           Removed the inconsistency in the internal representation

           of bit vectors produced by logical bitwise operations

           vis-a-vis the bit vectors created by the constructor.

           Previously, the logical bitwise operations resulted in bit 

           vectors that had their bits packed into lists of ints, 

           as opposed to arrays of unsigned shorts. 

 

       Version 1.3:

 

           (a) One more constructor mode included: When initializing

           a new bit vector with an integer value, you can now also

           specify a size for the bit vector.  The constructor 

           zero-pads the bit vector from the left with zeros. (b) The 

           BitVector class now supports 'if x in y' syntax to test if 

           the bit pattern 'x' is contained in the bit pattern 'y'. 

           (c) Improved syntax to conform to well-established Python 

           idioms. (d) What used to be a comment before the beginning 

           of each method definition is now a docstring.

 

       Version 1.2:

 

           (a) One more constructor mode included: You can now construct

           a bit vector directly from a string of 1's and 0's.  (b) The

           class now constructs a shortest possible bit vector from an

           integer value.  So the bit vector for the integer value 0 is

           just one bit of value 0, and so on. (c) All the rich

           comparison operators are now overloaded. (d) The class now

           includes a new method 'intValue()' that returns the unsigned

           integer value of a bit vector.  This can also be done through

           '__int__'. (e) The package now includes a unittest based

           framework for testing out an installation.  This is in a

           separate directory called "TestBitVector".

       

       Version 1.1.1:

 

           The function that does block reads from a disk file now peeks

           ahead at the end of each block to see if there is anything

           remaining to be read in the file.  If nothing remains, the

           more_to_read attribute of the BitVector object is set to

           False.  This simplifies reading loops. This version also

           allows BitVectors of size 0 to be constructed

 

 

       Version 1.1:

 

           I have changed the API significantly to provide more ways for

           constructing a bit vector.  As a result, it is now necessary

           to supply a keyword argument to the constructor.

       

 

 


    INSTALLATION:


 

       The BitVector class has been packaged using Distutils.  

       For installation, execute the following command-line in the 

       source directory (this is the directory that contains the 

       setup.py file after you have downloaded and uncompressed the 

       package):

 

           python setup.py install

 

       You have to have root privileges for this to work.  On Linux 

       distributions, this will install the module file at a location 

       that looks like

 

            /usr/lib/python2.5/site-packages/

 

       If you do not have root access, you have the option of 

       working directly off the directory in which you downloaded 

       the software by simply placing the following statements at 

       the top of your scripts that use the BitVector class

 

           import sys

           sys.path.append( "pathname_to_BitVector_directory" )

 

       To uninstall the module, simply delete the source directory,

       locate where BitVector was installed with "locate BitVector"

       and delete those files.  As mentioned above, the full 

       pathname to the installed version is likely to look like

       /usr/lib/python2.5/site-packages/BitVector*

 

       If you want to carry out a non-standard install of BitVector,

       look up the on-line information on Disutils by pointing your

       browser to 

 

              http://docs.python.org/dist/dist.html

 

 

 

 


    INTRODUCTION:


   

       The BitVector class for a memory-efficient packed representation

       of bit arrays and for logical operations on such arrays.  The

       core idea used in this Python script for bin packing is based on

       an internet posting by Josiah Carlson to the Pyrex mailing list.

 

       Operations supported on bit vectors:

 

              __getitem__

              __setitem__

              __len__

              __iter__

              __contains__

              __getslice__

              __str__

              __int__

              __add__

              __eq__, __ne__, __lt__, __le__, __gt__, __ge__

              |            for bitwise or

              &            for bitwise and              

              ^            for bitwise xor

              ~            for bitwise inversion

              <<           for circular rotation to the left

              >>           for circular rotation to the right

              +            for concatenation

              intValue()   for returning the integer value 

              divide_into_two

              permute

              unpermute

              pad_from_left

              pad_from_right

              read_bits_from_file

              write_to_file

              read_bits_from_fileobject

              write_bits_to_fileobject

              reset

              slice assignment

 

 

 

 


    CONSTRUCTING BIT VECTORS:


 

 

        You can construct a bit vector in six different ways.

   

        (1) You can construct a bit vector directly from either a tuple

            or a list of bits, as in

 

               bv =  BitVector( bitlist = [1,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1] ) 

 

        (2) You can construct a bit vector from an integer by

 

               bv =  BitVector( intVal = 56789 )

 

            The bits stored now will correspond to the binary

            representation of the integer.  The resulting bit vector is

            the shortest possible bit vector for the integer value

            supplied.  For example, when intVal is 0, the bit vector

            constructed will consist of just the bit 0.

 

 

        (3) When initializing a bit vector with an intVal as shown

            above, you can also specify a size for the bit vector:

 

               bv = BitVector( intVal = 0, size = 8 )

 

            will return the bit vector consisting of the bit pattern

            00000000.  The zero padding needed for meeting the size

            requirement is always on the left.  If the size supplied is

            smaller than what it takes to create the shortest possible

            bit vector for intVal, an exception is thrown.

 

                

        (4) You can create a zero-initialized bit vector of a given size

            by

 

               bv  = BitVector( size = 62 )

 

            This bit vector will hold exactly 62 bits, all initialized to

            the 0 bit value.

 

        (5) You can construct a bit vector from a disk file by a two-step

            procedure. First you construct an instance of bit vector by

   

               bv  =  BitVector( filename = 'somefile' )   

 

            This bit vector itself is incapable of holding the bits.  To

            now create bit vectors that actually hold the bits, you need

            to make the following sort of a call on the above variable

            bv:

 

               bv1 =  bv.read_bits_from_file( 64 )    

 

            bv1 will be a regular bit vector containing 64 bits from the

            disk file. If you want to re-read a file from the beginning

            for some reason, you must obviously first close the file

            object that was acquired with a call to the BitVector

            constructor with a filename argument.  This can be

            accomplished by

 

              bv.close_file_object()

 

        (6) You can construct a bit vector from a string of 1's and 0's

            by

 

               bv  =  BitVector( bitstring = '110011110000' )      

   

        (7) Yet another way to construct a bit vector is to read the bits

            directly from a file-like object, as in

  

               x = "111100001111"

               fileobj = StringIO.StringIO( x )

               bv = BitVector( fp = fileobj )

 

 

   


   OPERATIONS SUPPORTED BY THE BITVECTOR CLASS:


    


    DISPLAYING BIT VECTORS:


 

 

        1)  Since the BitVector class implements the __str__ method, a

            bit vector can be displayed on a terminal by

 

                  print bitvec

 

            Basically, you can always obtain the string representation

            of a bit vector by

 

                  str( bitvec )

 

            and integer value by

 

                  int( bitvec )

 

 

 


    ACCESSING AND SETTING INDIVIDUAL BITS AND SLICES:


 

   

        2)  Any single bit of a bit vector bv can be set to 1 or 0 by

 

                  bv[M] = 1_or_0

                  print bv[M]

 

            for accessing (and setting) the bit at the position that is

            indexed M.  You can retrieve the bit at position M by bv[M].

 

        3)  A slice of a bit vector obtained by

 

                  bv[i:j]

 

            is a bit vector constructed from the bits at index positions

            from i through j-1.

 

        4)  You can also carry out slice assignment:

 

                  bv1 = BitVector( size = 25 )

                  bv2 = BitVector( bitstring = '1010001' )

                  bv1[6:9]  = bv2[0:3]

                  bv3 = BitVector( bitstring = '101' )                 

                  bv1[0:3]  = bv3

 

            The first slice assignment will set the 6th, 7th, and 

            the 8th bits of the bit vector bv1 according to the first

            three bits of bv2.  The second slice assignment will set

            the first three bits of bv1 according to the three bits

            in bv3.

 

        5)  You can iterate over a bit vector, as illustrated by

 

                  for bit in bitvec:

                      print bit,   

 

            This is made possible by the override definition for the

            special __iter__() method.

 

        6)  Negative subscripts for array-like indexing are supported.

            Therefore,

 

                  bitvec[ -i ]

 

            is legal assuming that the index range is not violated.

 

        7)  You can reset a previously constructed bit vector to

            either the all zeros state or the all ones state by

 

                  bv1 = BitVector( size = 25 )

                  ...

                  ...

                  bv1.reset( 1 )

                  ...

                  ...

                  bv1.reset( 0 )

 

            The first call to reset() will set all the bits of

            bv1 to 1's and the second call all bit to 0's.

 

 

 


    LOGICAL OPERATIONS ON BIT VECTORS:


 

   

        8) Given two bit vectors bv1 and bv2, you can perform bitwise

           logical operations on them by

 

                  result_bv  =  bv1 ^ bv2

                  result_bv  =  bv1 & bv2

                  result_bv  =  bv1 | bv2

                  result_bv  =  ~bv1

 

 

 


    COMPARING BIT VECTORS:


 

        9) Given two bit vectors bv1 and bv2, you can carry out the

           following comparisons that return Boolean values:

 

                  bv1 ==  bv2

                  bv1 !=  bv2

                  bv1 <   bv2

                  bv1 <=  bv2

                  bv1 >   bv2

                  bv1 >=  bv2

 

           The equalities and inequalities are determined by the integer

           values associated with the bit vectors.

 

 

   

 


    OTHER SUPPORTED OPERATIONS:


 

   

       10)  You can permute and un-permute bit vectors:

 

                  bv_permuted   =  bv.permute( permutation_list )

 

                  bv_unpermuted =  bv.unpermute( permutation_list )

 

 

       11)  Left and right circular rotations can be carried out by

 

                  bitvec  << N 

 

                  bitvec  >> N

 

            for circular rotations to the left and right by N bit

            positions.

 

 

       12)  A bit vector containing an even number of bits can be

            divided into two equal parts by

 

                  [left_half, right_half] = bitvec.divide_into_two()

 

             where left_half and right_half hold references to the two

             returned bit vectors.

 

 

       13)  You can find the integer value of a bit array by

 

                  bitvec.invValue()

 

            or by

 

                  int( bitvec )

 

 

       14)  You can convert a bit vector into its string representation

            by

 

                  str( bitvec )

 

 

       15)  Because __add__ is supplied, you can always join two

            bit vectors by

 

                  bitvec3  =  bitvec1  +  bitvec2

 

            bitvec3 is a new bit vector that contains all the

            bits of bitvec1 followed by all the bits of bitvec2.

 

             

       16)  You can write a bit vector directly to a file, as

            illustrated by the following example that reads one bit

            vector from a file and then writes it to another

            file

 

                  bv = BitVector( filename = 'input.txt' )

                  bv1 = bv.read_bits_from_file(64)        

                  print bv1           

                  FILEOUT = open( 'output.bits', 'wb' )

                  bv1.write_to_file( FILEOUT )

                  FILEOUT.close()

                  bv = BitVector( filename = 'output.bits' )

                  bv2 = bv.read_bits_from_file( 64 )

                  print bv2

 

             IMPORTANT:  The size of bit vector must be a multiple of

                         of 8 for this write function to work.  If this

                         condition is not met, the function throws an

                         exception.

 

             IMPORTANT FOR WINDOWS USERS:  When writing an internally

                         generated bit vector out to a disk file, it

                         is important to open the file in the binary

                         mode as shown.  Otherwise, the bit pattern

                         00001010 ('\n') in your bitstring will be written 

                         out as 0000110100001010 ('\r\n'), which is the

                         linebreak on Windows machine.

 

 

       17)  You can also write a bit vector directly to a stream

            object, as illustrated by

 

                  fp_write = StringIO.StringIO()

                  bitvec.write_bits_to_fileobject( fp_write )

                  print fp_write.getvalue()         # 111100001111 

             

 

       18)  You can pad a bit vector from the left or from the

            right with a designated number of zeros

 

                  bitvec.pad_from_left( n )

 

                  bitvec.pad_from_right( n )

 

            In the first case, the new bit vector will be the same

            as the old bit vector except for the additional n zeros

            on the left.  The same thing happens in the second

            case except that now the additional n zeros will be on

            the right.

 

       19)  You can test if a bit vector x is contained in another bit

            vector y by using the syntax 'if x in y'.  This is made

            possible by the override definition for the special

            __contains__() method.

 

 

 


    HOW THE BIT VECTORS ARE STORED:


 

   

        The bits of a bit array are stored in 16-bit unsigned ints.

        After resolving the argument with which the constructor is

        called (which happens in lines (A2) through (A70) of the file

        BitVector.py), the very first thing that the constructor does is

        to figure out in line (A78) as to how many of those 2-byte ints

        it needs for the bits.  For example, if you wanted to store a

        64-bit array, the variable 'two_byte_ints_needed' in line (A78)

        would be set to 4. (This does not mean that the size of a bit

        vector must be a multiple of 16.  Any sized bit vectors can

        constructed using the required number of two-byte ints.) Line

        (A79) then creates an array of 2-byte ints and initializes it

        with the required number of zeros.  Lines (A80) then shifts the

        bits into the array of two-byte ints.

 

        As mentioned above, note that it is not necessary for the size

        of the vector to be a multiple of 16 even though we are using

        C's unsigned short as as a basic unit for storing the bit

        arrays.  The class BitVector keeps track of the actual number of

        bits in the bit vector through the "size" instance attribute.

 

        With regard to the code in lines (A2) through (A77) of the file

        BitVector.py, note that, except for one case, the constructor

        must be called with a single keyword argument, which determines

        how the bit vector will be constructed.  The single exception to

        this rule is for the keyword argument 'intVal' which can be used

        along with the 'size' keyword argument.  When 'intVal' is used

        with the 'size' option, the bit vector constructed for the

        integer is the shortest possible bit vector.  On the other hand,

        when 'size' is also specified, the bit vector is padded with

        zeroes from the left so that it has the specified size.

 

        Lines (A16) through (A22) are for the following sort of a call

 

               bv = BitVector( filename = 'myfilename' )

 

        This call returns a bit vector on which you must subsequently

        invoke the 'read_bits_from_file()' method to actually obtain a

        bit vector consisting of the bits that constitute the

        information stored in the file.

 

        Lines (A23) through (A28) are for the case when you want to

        construct a bit vector by reading the bits off a file-like

        object, as in

 

              x = "111100001111"

              fileobj = StringIO.StringIO( x )

              bv = BitVector( fp = fileobj )

 

        Lines (A29) through (A61) are for the case when you want to

        construct a bit vector from an integer, as in

 

              bv = BitVector( intVal = 123456 )

 

        The bits stored in the bit vector will correspond to the binary

        representation of the integer argument provided.  The bit vector

        constructed with the above call will be the shortest possible

        bit vector for the integer supplied.  As a case in point, when

        the intVal is 0, the bit vector will consist of a single bit

        which will be 0 also.  The code in lines (A27) through (A59) can

        also handle the following sort of a call

 

              bv = BitVector( intVal = 46, size = 16 )        

 

        which returns a bit vector of a specfic size by padding the

        shortest possible bit vector the the intVal with zeros from the

        left.

        

        Lines (A62) through (A66) are for constructing a bit vector with

        just the size information, as in

 

              bv = BitVector( size = 61 )

 

        This returns a bit vector that will hold exactly 61 bits, all

        initialized to the zero value.

 

        Lines (A67) through (A71) are for constructing a bit vector from

        a bitstring, as in

 

              bv = BitVector( bitstring = '00110011111' )

 

        Finally, lines (A72) through (A75) are for constructing a bit

        vector from a list or a tuple of the individual bits:

          

              bv = BitVector( bitlist = (1, 0, 1, 1, 0, 0, 1) )

 

        The bit vector constructed is initialized with the supplied

        bits.

 

   

 


    ACKNOWLEDGEMENTS:


 

        The author is grateful to Oleg Broytmann for suggesting many

        improvements that were incorporated in Version 1.1 of this

        package.  The author would like to thank Kurt Schwehr whose

        email resulted in the creation of Version 1.2.  Kurt also caught

        an error in my earlier version of 'setup.py' and suggested a

        unittest based approach to the testing of the package.  Kurt

        also supplied the Makefile that is included in this

        distribution.  The author would also like to thank all (Scott

        Daniels, Blair Houghton, and Steven D'Aprano) for their

        responses to my comp.lang.python query concerning how to make a

        Python input stream peekable.  This feature was included in

        Version 1.1.1.

 

        With regard to the changes incorporated in Version 1.3, thanks

        are owed to Kurt Schwehr and Gabriel Ricardo for bringing to my

        attention the bug related to the intVal method of initializing a

        bit vector when the value of intVal exceeded sys.maxint. This

        problem is fixed in Version 1.3.  Version 1.3 also includes many

        other improvements that make the syntax better conform to the

        standard idioms of Python.  These changes and the addition of

        the new constructor mode (that allows a bit vector of a given

        size to be constructed from an integer value) are also owing to

        Kurt's suggestions.

 

        With regard to the changes incorporated in Version 1.3.1, I

        would like to thank Michael Haggerty for noticing that the

        bitwise logical operators resulted in bit vectors that had their

        bits packed into lists of ints, as opposed to arrays of 

        unsigned shorts.  This inconsistency in representation has been 

        removed in version 1.3.1.  Michael has also suggested that 

        since BitVector is mutable, I should be overloading __iand__(), 

        __ior__(), etc., for in-place modifications of bit vectors.  

        Michael certainly makes a good point. But I am afraid that this 

        change will break the code for the existing users of the 

        BitVector class. 

 

        I thank Mathieu Roy for bringing to my attention the problem

        with writing bitstrings out to a disk files on Windows 

        machines.  This turned out to be a problem more with the

        documentation than with the BitVector class itself.  On a 

        Windows machine, it is particularly important that a file

        you are writing a bitstring into be opened in binary mode

        since otherwise the bit pattern 00001010 ('\n') will be written 

        out as 0000110100001010 ('\r\n').  This documentation fix 

        resulted in Version 1.3.2.

 

        With regard to Version 1.4, the suggestions/bug reports

        made by John Kominek, Bob Morse, and Steve Ward contributed

        to this version.  I wish to thank all three. John wanted me 

        to equip the class with a reset() method so that a previously

        constructed class could be reset to either all 0's or all

        1's. Bob spotted loose local variables in the implementation

        --- presumably left over from the debugging phase of the code.

        Bob recommended that I clean up the code with pychecker. That

        has been done.  Steve noticed that slice assignment was not

        working.  It should work now.

 

 

 


    ABOUT THE AUTHOR:


 

        Avi Kak is the author of "Programming with Objects: A

        Comparative Presentation of Object-Oriented Programming

        with C++ and Java", published by John-Wiley in 2003. This

        book presents a new approach to the combined learning of

        two large object-oriented languages, C++ and Java.  It is

        being used as a text in a number of educational programs

        around the world.  This book has also been translated into

        Chinese.  Further information on the book is available at

        www.programming-with-objects.com

        

 

 


    SOME EXAMPLE CODE:


 

        #!/usr/bin/env python

        import BitVector

 

        # Construct a bit vector from a list or tuple of bits:

        bv = BitVector.BitVector( bitlist = (1, 0, 0, 1) )

        print bv                                # 1001

 

        # Construct a bit vector from an integer:

        bv = BitVector.BitVector( intVal = 5678 )

        print bv                                # 0001011000101110

 

        # Construct a bit vector of a given size from a given

        # integer:

        bv = BitVector( intVal = 45, size = 16 )

        print bv                                # 0000000000101101

 

        # Construct a zero-initialized bit vector of a given size:

        bv = BitVector.BitVector( size = 5 )

        print bv                                # 00000

 

        # Construct a bit vector from a bit string:

        bv = BitVector.BitVector( bitstring = '110001' )     

        print bv[0], bv[1], bv[2], bv[3], bv[4], bv[5]       # 1 1 0 0 0 1

        print bv[-1], bv[-2], bv[-3], bv[-4], bv[-5], bv[-6] # 1 0 0 0 1 1

 

        # Construct a bit vector from a file like object:

        import StringIO

        x = "111100001111"

        fp_read = StringIO.StringIO( x )

        bv = BitVector.BitVector( fp = fp_read )

        print bv                                    # 111100001111 

 

        # Experiments with bitwise logical operations:

        bv3 = bv1 | bv2                              

        bv3 = bv1 & bv2

        bv3 = bv1 ^ bv2

        bv6 = ~bv5

 

        # Find the length of a bit vector

        print len( bitvec )

 

        # Find the integer value of a bit vector

        print int( bitvec )

 

        # Open a file for reading bit vectors from

        bv = BitVector.BitVector( filename = 'TestBitVector/testinput1.txt' )

        print bv                                    # nothing yet

        bv1 = bv.read_bits_from_file(64)    

        print bv1                            # first 64 bits from the file

 

        # Divide a bit vector into two equal sub-vectors:

        [bv1, bv2] = bitvec.divide_into_two()

 

        # Permute and Un-Permute a bit vector:

        bv2 = bitvec.permute( permutation_list )

        bv2 = bitvec.unpermute( permutation_list )

 

        # Try circular shifts to the left and to the right

        bitvec << 7

        bitvec >> 7

 

        # Try 'if x in y' syntax for bit vectors:

        bv1 = BitVector( bitstring = '0011001100' )

        bv2 = BitVector( bitstring = '110011' )

        if bv2 in bv1:

            print "%s is in %s" % (bv2, bv1)

        else:

            print "%s is not in %s" % (bv2, bv1)

 

        .....

        .....

 


        (For a more complete working example, see the example code in

         the BitVectorDemo.py file in the Examples sub-directory.)








 

Modules

    

       

array

operator







 

Classes

    

       



BitVectorIterator

__builtin__.object





BitVector






 





 

class BitVector(__builtin__.object)

    

    
Methods defined here:


__add__(self, other)
Concatenate the argument bit vector with the bit

vector on which the method is invoked.  Return the

concatenated bit vector as a new BitVector object.



__and__(self, other)
Take a bitwise 'and' of the bit vector on which the method is

invoked with the argument bit vector.  Return the result as a

new bit vector.  If the two bit vectors are not of the same

size, pad the shorter one with zero's from the left.



__contains__(self, otherBitVec)
This supports 'if x in y' and 'if x not in y'

syntax for bit vectors.



__eq__(self, other)



__ge__(self, other)



__getitem__ = _getbit(self, posn)



__getslice__(self, i, j)
Allow slicing with [i:j], [:], etc.



__gt__(self, other)



__init__(self, *args, **kwargs)



__int__ = intValue(self)



__invert__(self)
Invert the bits in the bit vector on which the

method is invoked and return the result as a new

bit vector.



__iter__(self)
To allow iterations over a bit vector by supporting the

'for bit in bit_vector' syntax:



__le__(self, other)



__len__ = _getsize(self)



__lshift__(self, n)
For an in-place left circular shift by n bit positions



__lt__(self, other)



__ne__(self, other)



__or__(self, other)
Take a bitwise 'or' of the bit vector on which the

method is invoked with the argument bit vector.  Return

the result as a new bit vector.  If the two bit vectors

are not of the same size, pad the shorter one with

zero's from the left.



__rshift__(self, n)
For an in-place right circular shift by n bit positions.



__setitem__(self, pos, item)
This is needed for both slice assignments and for 

index assignments.  It checks the types of pos and item

to see if the call is for slice assignment.  For slice

assignment, pos must be of type 'slice' and item of 

type BitVector.  For index assignment, the argument types

are checked in the _setbit() method.



__str__(self)
To create a print representation



__xor__(self, other)
Take a bitwise 'xor' of the bit vector on which

the method is invoked with the argument bit vector.

Return the result as a new bit vector.  If the two

bit vectors are not of the same size, pad the shorter

one with zero's from the left.



circular_rot_left(self)
This is merely another implementation of the method

circular_rotate_left_by_one() shown above.  This one

does NOT use map functions.  This method carries out a

one-bit left circular shift of a bit vector.



circular_rot_right(self)
This is merely another implementation of the method

circular_rotate_right_by_one() shown above.  This one

does NOT use map functions.  This method does a one-bit

right circular shift of a bit vector.



circular_rotate_left_by_one(self)
For a one-bit in-place left circular shift



circular_rotate_right_by_one(self)
For a one-bit in-place right circular shift



close_file_object(self)
For closing a file object that was used for reading

the bits into one or more BitVector objects.



divide_into_two(self)
Divides an even-sized bit vector into two and returns

the two halves as a list of two bit vectors.



intValue(self)
Return the integer value of a bitvector



pad_from_left(self, n)
Pad a bit vector with n zeros from the left



pad_from_right(self, n)
Pad a bit vector with n zeros from the right



permute(self, permute_list)
Permute a bit vector according to the indices

shown in the second argument list.  Return the

permuted bit vector as a new bit vector.



read_bits_from_file(self, blocksize)
Read blocksize bits from a disk file and return a

BitVector object containing the bits.  If the file

contains fewer bits than blocksize, construct the

BitVector object from however many bits there are

in the file.  If the file contains zero bits, return

a BitVector object of size attribute set to 0.



read_bits_from_fileobject(self, fp)
This function is meant to read a bit string from a 

file like object.



reset(self, val)
Resets a previously created BitVector to either all

zeros or all ones depending on the argument val.



unpermute(self, permute_list)
Unpermute the bit vector according to the

permutation list supplied as the second argument.

If you first permute a bit vector by using permute()

and then unpermute() it using the same permutation

list, you will get back the original bit vector.



write_bits_to_fileobject(self, fp)
This function is meant to write a bit vector directly to

a file like object.  Note that whereas 'write_to_file'

method creates a memory footprint that corresponds exactly

to the bit vector, the 'write_bits_to_fileobject' actually

writes out the 1's and 0's as individual items to the

file object.  That makes this method convenient for

creating a string representation of a bit vector,

especially if you use the StringIO class, as shown in

the test code.



write_to_file(self, file_out)
(Contributed by Joe Davidson) Write the bitvector

to the file object file_out.  (A file object is

returned by a call to open()). Since all file I/O

is byte oriented, the bitvector must be multiple

of 8 bits. Each byte treated as MSB first (0th index).




Data descriptors defined here:


__dict__


dictionary for instance variables (if defined)




__weakref__


list of weak references to the object (if defined)




 





 

class BitVectorIterator

    

    
Methods defined here:


__init__(self, bitvec)



__iter__(self)



next(self)








 

Data

    

       
__author__ = 'Avinash Kak (kak@purdue.edu)'

__copyright__ = '(C) 2008 Avinash Kak. GNU GPL 2.'

__date__ = '2008-April-18'

__url__ = 'http://RVL4.ecn.purdue.edu/~kak/dist/BitVector-1.4.html'

__version__ = '1.4'





 

Author

    

       
Avinash Kak (kak@purdue.edu)