BitVector
umontreal.iro.lecuyer.util

Class BitVector

  • All Implemented Interfaces:
    Serializable, Cloneable


    public class BitVectorextends Objectimplements Serializable, Cloneable
    This class implements vectors of bits and the operations needed to use them. The vectors can be of arbitrary length. The operations provided are all the binary operations available to the int and long primitive types in Java.

    All bit operations are present in two forms: a normal form and a self form. The normal form returns a newly created object containing the result, while the self form puts the result in the calling object (this). The return value of the self form is the calling object itself. This is done to allow easier manipulation of the results, making it possible to chain operations.

    See Also:
    Serialized Form
    • Constructor Summary

      Constructors 
      Constructor and Description
      BitVector(BitVector that)
      Creates a copy of the BitVector that.
      BitVector(int length)
      Creates a new BitVector of length length with all its bits set to 0.
      BitVector(int[] vect)
      Creates a new BitVector using the data in vect.
      BitVector(int[] vect, int length)
      Creates a new BitVector of length length using the data in vect.
    • Method Summary

      Methods 
      Modifier and TypeMethod and Description
      BitVectorand(BitVector that)
      Returns a BitVector which is the result of the and operator with both the this and that BitVector's.
      Objectclone()
      Creates a copy of the BitVector.
      voidenlarge(int size)
      Resizes the BitVector so that its length is equal to size.
      voidenlarge(int size, boolean filling)
      Resizes the BitVector so that its length is equal to size.
      booleanequals(BitVector that)
      Verifies if two BitVector's have the same length and the same data.
      booleangetBool(int pos)
      Gives the value of the bit in position pos.
      intgetInt(int pos)
      Returns an int containing all the bits in the interval [pos×32,pos×32 + 31].
      BitVectornot()
      Returns a BitVector which is the result of the not operator on the current BitVector.
      BitVectoror(BitVector that)
      Returns a BitVector which is the result of the or operator with both the this and that BitVector's.
      booleanscalarProduct(BitVector that)
      Returns the scalar product of two BitVector's modulo 2.
      BitVectorselfAnd(BitVector that)
      Applies the and operator on this with that.
      BitVectorselfNot()
      Applies the not operator on the current BitVector and returns it.
      BitVectorselfOr(BitVector that)
      Applies the or operator on this with that.
      BitVectorselfShift(int j)
      Shift all the bits of the current BitVector j positions to the right if j is positive, and j positions to the left if j is negative.
      BitVectorselfXor(BitVector that)
      Applies the xor operator on this with that.
      voidsetBool(int pos, boolean value)
      Sets the value of the bit in position pos.
      BitVectorshift(int j)
      Returns a BitVector equal to the original with all the bits shifted j positions to the right if j is positive, and shifted j positions to the left if j is negative.
      intsize()
      Returns the length of the BitVector.
      StringtoString()
      Returns a string containing all the bits of the BitVector, starting with the highest order bit and finishing with the lowest order bit.
      BitVectorxor(BitVector that)
      Returns a BitVector which is the result of the xor operator applied on this and that.
    • Constructor Detail

      • BitVector

        public BitVector(int length)
        Creates a new BitVector of length length with all its bits set to 0.
        Parameters:
        length - the length of the BitVector
      • BitVector

        public BitVector(int[] vect,         int length)
        Creates a new BitVector of length length using the data in vect. Component vect[0] makes the 32 lowest order bits, with vect[1] being the 32 next lowest order bits, and so on. The normal bit order is then used to fill the 32 bits (the first bit is the lowest order bit and the last bit is largest order bit). Note that the sign bit is used as the largest order bit.
        Parameters:
        vect - the bits data
        length - the length of the vector
        Throws:
        IllegalArgumentException - when the length of vect is not compatible with the length provided
      • BitVector

        public BitVector(int[] vect)
        Creates a new BitVector using the data in vect. The length of the BitVector is always equals to 32 times the length of vect.
        Parameters:
        vect - the bits data
      • BitVector

        public BitVector(BitVector that)
        Creates a copy of the BitVector that.
        Parameters:
        that - the BitVector to copy
    • Method Detail

      • clone

        public Object clone()
        Creates a copy of the BitVector.
        Overrides:
        clone in class Object
        Returns:
        a deep copy of the BitVector
      • equals

        public boolean equals(BitVector that)
        Verifies if two BitVector's have the same length and the same data.
        Parameters:
        that - the other BitVector to compare to
        Returns:
        if the two BitVector's are identiqual
      • size

        public int size()
        Returns the length of the BitVector.
        Returns:
        the length of the BitVector
      • enlarge

        public void enlarge(int size,           boolean filling)
        Resizes the BitVector so that its length is equal to size. If the BitVector is enlarged, then the newly added bits are given the value 1 if filling is set to true and 0 otherwise.
        Parameters:
        size - the new size of the BitVector
        filling - the state of the new bits
      • enlarge

        public void enlarge(int size)
        Resizes the BitVector so that its length is equal to size. Any new bit added is set to 0.
        Parameters:
        size - the new size of the BitVector
      • getBool

        public boolean getBool(int pos)
        Gives the value of the bit in position pos. If the value is 1, returns true; otherwise, returns false.
        Parameters:
        pos - the position of the checked bit
        Returns:
        the value of the bit as a boolean
        Throws:
        ArrayIndexOutOfBoundsException - if pos is outside the range of the BitVector
      • setBool

        public void setBool(int pos,           boolean value)
        Sets the value of the bit in position pos. If value is equal to true, sets it to 1; otherwise, sets it to 0.
        Parameters:
        pos - the position of the bit to modify
        value - the new value of the bit as a boolean
        Throws:
        ArrayIndexOutOfBoundsException - if pos is outside the range of the BitVector
      • getInt

        public int getInt(int pos)
        Returns an int containing all the bits in the interval [pos×32,pos×32 + 31].
        Parameters:
        pos - the selected position
        Returns:
        the int at the specified position
        Throws:
        ArrayIndexOutOfBoundsException - if pos is outside the range of the BitVector
      • toString

        public String toString()
        Returns a string containing all the bits of the BitVector, starting with the highest order bit and finishing with the lowest order bit. The bits are grouped by groups of 8 bits for ease of reading.
        Overrides:
        toString in class Object
        Returns:
        all the bits of the BitVector
      • not

        public BitVector not()
        Returns a BitVector which is the result of the not operator on the current BitVector. The not operator is equivalent to the ~ operator in Java and thus swap all bits (bits previously set to 0 become 1 and bits previously set to 1 become 0).
        Returns:
        the effect of the not operator
      • selfNot

        public BitVector selfNot()
        Applies the not operator on the current BitVector and returns it.
        Returns:
        the BitVector itself
      • xor

        public BitVector xor(BitVector that)
        Returns a BitVector which is the result of the xor operator applied on this and that. The xor operator is equivalent to the ^ operator in Java. All bits which were set to 0 in one of the vector and to 1 in the other vector are set to 1. The others are set to 0. This is equivalent to the addition in modulo 2 arithmetic.
        Parameters:
        that - the second operand to the xor operator
        Returns:
        the result of the xor operation
      • selfXor

        public BitVector selfXor(BitVector that)
        Applies the xor operator on this with that. Stores the result in this and returns it.
        Parameters:
        that - the second operand to the xor operator
        Returns:
        this
      • and

        public BitVector and(BitVector that)
        Returns a BitVector which is the result of the and operator with both the this and that BitVector's. The and operator is equivalent to the & operator in Java. Only bits which are set to 1 in both this and that are set to 1 in the result, all the others are set to 0.
        Parameters:
        that - the second operand to the and operator
        Returns:
        the result of the and operation
      • selfAnd

        public BitVector selfAnd(BitVector that)
        Applies the and operator on this with that. Stores the result in this and returns it.
        Parameters:
        that - the second operand to the and operator
        Returns:
        this
      • or

        public BitVector or(BitVector that)
        Returns a BitVector which is the result of the or operator with both the this and that BitVector's. The or operator is equivalent to the | operator in Java. Only bits which are set to 0 in both this and that are set to to 0 in the result, all the others are set to 1.
        Parameters:
        that - the second operand to the or operator
        Returns:
        the result of the or operation
      • selfOr

        public BitVector selfOr(BitVector that)
        Applies the or operator on this with that. Stores the result in this and returns it.
        Parameters:
        that - the second operand to the or operator
        Returns:
        this
      • shift

        public BitVector shift(int j)
        Returns a BitVector equal to the original with all the bits shifted j positions to the right if j is positive, and shifted j positions to the left if j is negative. The new bits that appears to the left or to the right are set to 0. If j is positive, this operation is equivalent to the »> operator in Java, otherwise, it is equivalent to the « operator.
        Parameters:
        j - the size of the shift
        Returns:
        the shifted BitVector
      • selfShift

        public BitVector selfShift(int j)
        Shift all the bits of the current BitVector j positions to the right if j is positive, and j positions to the left if j is negative. The new bits that appears to the left or to the rigth are set to 0. Returns this.
        Parameters:
        j - the size of the shift
        Returns:
        this
      • scalarProduct

        public boolean scalarProduct(BitVector that)
        Returns the scalar product of two BitVector's modulo 2. It returns true if there is an odd number of bits with a value of 1 in the result of the and operator applied on this and that, and returns false otherwise.
        Parameters:
        that - the other BitVector with which to do the scalar product
        Returns:
        the scalar product

SCaVis 2.2 © jWork.ORG