umontreal.iro.lecuyer.util

## Class BitVector

- java.lang.Object
- umontreal.iro.lecuyer.util.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 Type Method and Description `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`.

### 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`.

#### 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.

#### 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 1.8 © jWork.org**