Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## umontreal.iro.lecuyer.util
Class BitVector

    java.lang.Object
      umontreal.iro.lecuyer.util.BitVector

All Implemented Interfaces:
  Serializable, Cloneable

    public class BitVector

extends Object
implements 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
`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
`BitVector` | `and(BitVector that)` Returns a `BitVector` which is the result of the `and` operator with both the `this` and `that` `BitVector`'s.
`Object` | `clone()` Creates a copy of the `BitVector`.
`void` | `enlarge(int size)` Resizes the `BitVector` so that its length is equal to `size`.
`void` | `enlarge(int size, boolean filling)` Resizes the `BitVector` so that its length is equal to `size`.
`boolean` | `equals(BitVector that)` Verifies if two `BitVector`'s have the same length and the same data.
`boolean` | `getBool(int pos)` Gives the value of the bit in position `pos`.
`int` | `getInt(int pos)` Returns an `int` containing all the bits in the interval [`pos`×32,`pos`×32 + 31].
`BitVector` | `not()` Returns a `BitVector` which is the result of the `not` operator on the current `BitVector`.
`BitVector` | `or(BitVector that)` Returns a `BitVector` which is the result of the `or` operator with both the `this` and `that` `BitVector`'s.
`boolean` | `scalarProduct(BitVector that)` Returns the scalar product of two `BitVector`'s modulo 2.
`BitVector` | `selfAnd(BitVector that)` Applies the `and` operator on `this` with `that`.
`BitVector` | `selfNot()` Applies the `not` operator on the current `BitVector` and returns it.
`BitVector` | `selfOr(BitVector that)` Applies the `or` operator on `this` with `that`.
`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.
`BitVector` | `selfXor(BitVector that)` Applies the `xor` operator on `this` with `that`.
`void` | `setBool(int pos, boolean value)` Sets the value of the bit in position `pos`.
`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.
`int` | `size()` Returns the length of the `BitVector`.
`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.
`BitVector` | `xor(BitVector that)` Returns a `BitVector` which is the result of the `xor` operator applied on `this` and `that`.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

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

Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

To submit a bug or ask questions, send an e-mail to Pierre L'Ecuyer.