This module implements efficient methods for handling bit vectors.
It is intended to serve as a base class for other applications or application classes, such as implementing sets or performing big integer arithmetic.
All methods are implemented in C internally for maximum performance.
The module also provides overloaded arithmetic and relational operators for maximum ease of use.
Version
$version = Bit::Vector->Version();
Word_Bits
$bits = Bit::Vector->Word_Bits(); # bits in a machine word
Long_Bits
$bits = Bit::Vector->Long_Bits(); # bits in an unsigned long
new
$vector = Bit::Vector->new($bits); # bit vector constructor
new
$vec2 = $vec1->new($bits); # alternative constructor
Shadow
$vec2 = $vec1->Shadow(); # new vector, same size but empty
Clone
$vec2 = $vec1->Clone(); # new vector, exact copy
Concat
$vector = $vec1->Concat($vec2);
Concat_List
$vector = $vec1->Concat_List($vec2,$vec3,...);
$vector = Bit::Vector::Concat_List(@bitvectors);
Size
$bits = $vector->Size();
Resize
$vector->Resize($bits);
$vector->Resize($vector->Size()+5);
$vector->Resize($vector->Size()-5);
Copy
$vec2->Copy($vec1);
Empty
$vector->Empty();
Fill
$vector->Fill();
Flip
$vector->Flip();
Primes
$vector->Primes(); # Sieve of Erathostenes
Reverse
$vec2->Reverse($vec1);
Interval_Empty
$vector->Interval_Empty($min,$max);
Interval_Fill
$vector->Interval_Fill($min,$max);
Interval_Flip
$vector->Interval_Flip($min,$max);
Interval_Reverse
$vector->Interval_Reverse($min,$max);
Interval_Scan_inc
if (($min,$max) = $vector->Interval_Scan_inc($start))
Interval_Scan_dec
if (($min,$max) = $vector->Interval_Scan_dec($start))
Interval_Copy
$vec2->Interval_Copy($vec1,$offset2,$offset1,$length);
Interval_Substitute
$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1);
is_empty
if ($vector->is_empty())
is_full
if ($vector->is_full())
equal
if ($vec1->equal($vec2))
Compare
if ($vec1->Compare($vec2) == 0) # true if $vec1 == $vec2
if ($vec1->Compare($vec2) != 0) # true if $vec1 != $vec2
if ($vec1->Compare($vec2) < 0) # true if $vec1 < $vec2
if ($vec1->Compare($vec2) <= 0) # true if $vec1 <= $vec2
if ($vec1->Compare($vec2) > 0) # true if $vec1 > $vec2
if ($vec1->Compare($vec2) >= 0) # true if $vec1 >= $vec2
to_Hex
$string = $vector->to_Hex();
from_hex
$ok = $vector->from_hex($string);
to_Bin
$string = $vector->to_Bin();
from_bin
$ok = $vector->from_bin($string);
to_Dec
$string = $vector->to_Dec();
from_dec
$ok = $vector->from_dec($string);
to_Enum
$string = $vector->to_Enum(); # e.g. "2,3,5-7,11,13-19"
from_enum
$ok = $vector->from_enum($string);
Bit_Off
$vector->Bit_Off($index);
Bit_On
$vector->Bit_On($index);
bit_flip
$bit = $vector->bit_flip($index);
bit_test, contains
$bit = $vector->bit_test($index);
$bit = $vector->contains($index);
if ($vector->bit_test($index))
if ($vector->contains($index))
Bit_Copy
$vector->Bit_Copy($index,$bit);
lsb
$bit = $vector->lsb();
msb
$bit = $vector->msb();
rotate_left
$carry = $vector->rotate_left();
rotate_right
$carry = $vector->rotate_right();
shift_left
$carry = $vector->shift_left($carry);
shift_right
$carry = $vector->shift_right($carry);
Move_Left
$vector->Move_Left($bits); # shift left "$bits" positions
Move_Right
$vector->Move_Right($bits); # shift right "$bits" positions
Insert
$vector->Insert($offset,$bits);
Delete
$vector->Delete($offset,$bits);
increment
$carry = $vector->increment();
decrement
$carry = $vector->decrement();
add
$carry = $vec3->add($vec1,$vec2,$carry);
subtract
$carry = $vec3->subtract($vec1,$vec2,$carry);
Negate
$vec2->Negate($vec1);
Absolute
$vec2->Absolute($vec1);
Sign
if ($vector->Sign() == 0)
if ($vector->Sign() != 0)
if ($vector->Sign() < 0)
if ($vector->Sign() <= 0)
if ($vector->Sign() > 0)
if ($vector->Sign() >= 0)
Multiply
$vec3->Multiply($vec1,$vec2);
Divide
$quot->Divide($vec1,$vec2,$rest);
GCD (Greatest Common Divisor)
$vec3->GCD($vec1,$vec2);
Block_Store
$vector->Block_Store($buffer);
Block_Read
$buffer = $vector->Block_Read();
Word_Size
$size = $vector->Word_Size(); # number of words in "$vector"
Word_Store
$vector->Word_Store($offset,$word);
Word_Read
$word = $vector->Word_Read($offset);
Word_List_Store
$vector->Word_List_Store(@words);
Word_List_Read
@words = $vector->Word_List_Read();
Word_Insert
$vector->Word_Insert($offset,$count);
Word_Delete
$vector->Word_Delete($offset,$count);
Chunk_Store
$vector->Chunk_Store($chunksize,$offset,$chunk);
Chunk_Read
$chunk = $vector->Chunk_Read($chunksize,$offset);
Chunk_List_Store
$vector->Chunk_List_Store($chunksize,@chunks);
Chunk_List_Read
@chunks = $vector->Chunk_List_Read($chunksize);
Index_List_Remove
$vector->Index_List_Remove(@indices);
Index_List_Store
$vector->Index_List_Store(@indices);
Index_List_Read
@indices = $vector->Index_List_Read();
Union
$set3->Union($set1,$set2);
Intersection
$set3->Intersection($set1,$set2);
Difference
$set3->Difference($set1,$set2);
ExclusiveOr
$set3->ExclusiveOr($set1,$set2);
Complement
$set2->Complement($set1);
subset
if ($set1->subset($set2)) # true if $set1 is subset of $set2
Norm
$norm = $set->Norm();
Min
$min = $set->Min();
Max
$max = $set->Max();
Multiplication
$matrix3->Multiplication($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);
Closure
$matrix->Closure($rows,$cols);
Transpose
$matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1);
Configuration
$config = Bit::Vector->Configuration();
Bit::Vector->Configuration($config);
$config = Bit::Vector->Configuration($config);
Method names completely in lower case indicate a boolean return value.
(Except for the bit vector constructor method ``new()'', of course.)
Boolean return values from this module are always a numeric zero (``0'') for ``false'' and a numeric one (``1'') for ``true''.
All numeric input parameters are regarded as being unsigned by this module.
As a consequence, whenever you pass a negative number as an argument to some method in this module, it will be treated as a (usually very large) positive number due to its internal 2's complement representation, usually resulting in an ``index out of range'' error message and program abortion.
Note that this does not apply to ``big integer'' decimal numbers, which are (usually) passed as strings, and which may of course be negative.
perl(1), perlsub(1), perlmod(1),
perlref(1), perlobj(1), perlbot(1),
perltoot(1), perlxs(1),
perlxstut(1), perlguts(1),
overload(3).