Syntax-K

Know-How für Ihr Projekt

Perl Documentation

NAME

Bit::Vector - Efficient bit vector, set of integers and "big int" math library

SYNOPSIS

OVERLOADED OPERATORS

See Bit::Vector::Overload(3).

MORE STRING IMPORT/EXPORT

See Bit::Vector::String(3).

CLASS METHODS

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
@veclist = Bit::Vector->new($bits,$count);
new_Hex
    $vector = Bit::Vector->new_Hex($bits,$string);
new_Bin
    $vector = Bit::Vector->new_Bin($bits,$string);
new_Dec
    $vector = Bit::Vector->new_Dec($bits,$string);
new_Enum
    $vector = Bit::Vector->new_Enum($bits,$string);
Concat_List
    $vector = Bit::Vector->Concat_List(@vectors);

OBJECT METHODS

new
    $vec2 = $vec1->new($bits);  #  alternative call of constructor
@veclist = $vec->new($bits,$count);
Shadow
    $vec2 = $vec1->Shadow();  #  new vector, same size but empty
Clone
    $vec2 = $vec1->Clone();  #  new vector, exact duplicate
Concat
    $vector = $vec1->Concat($vec2);
Concat_List
    $vector = $vec1->Concat_List($vec2,$vec3,...);
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))
Lexicompare (unsigned)
    if ($vec1->Lexicompare($vec2) == 0)
    if ($vec1->Lexicompare($vec2) != 0)
    if ($vec1->Lexicompare($vec2) <  0)
    if ($vec1->Lexicompare($vec2) <= 0)
    if ($vec1->Lexicompare($vec2) >  0)
    if ($vec1->Lexicompare($vec2) >= 0)
Compare (signed)
    if ($vec1->Compare($vec2) == 0)
    if ($vec1->Compare($vec2) != 0)
    if ($vec1->Compare($vec2) <  0)
    if ($vec1->Compare($vec2) <= 0)
    if ($vec1->Compare($vec2) >  0)
    if ($vec1->Compare($vec2) >= 0)
to_Hex
    $string = $vector->to_Hex();
from_Hex
    $vector->from_Hex($string);
to_Bin
    $string = $vector->to_Bin();
from_Bin
    $vector->from_Bin($string);
to_Dec
    $string = $vector->to_Dec();
from_Dec
    $vector->from_Dec($string);
to_Enum
    $string = $vector->to_Enum();  #  e.g. "2,3,5-7,11,13-19"
from_Enum
    $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 (least significant bit)
    $vector->LSB($bit);
MSB (most significant bit)
    $vector->MSB($bit);
lsb (least significant bit)
    $bit = $vector->lsb();
msb (most significant bit)
    $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();
inc
    $overflow = $vec2->inc($vec1);
dec
    $overflow = $vec2->dec($vec1);
add
    $carry = $vec3->add($vec1,$vec2,$carry);
    ($carry,$overflow) = $vec3->add($vec1,$vec2,$carry);
subtract
    $carry = $vec3->subtract($vec1,$vec2,$carry);
    ($carry,$overflow) = $vec3->subtract($vec1,$vec2,$carry);
Neg
Negate
    $vec2->Neg($vec1);
    $vec2->Negate($vec1);
Abs
Absolute
    $vec2->Abs($vec1);
    $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)
    $vecgcd->GCD($veca,$vecb);
    $vecgcd->GCD($vecx,$vecy,$veca,$vecb);
Power
    $vec3->Power($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();
Or
Union
    $vec3->Or($vec1,$vec2);
    $set3->Union($set1,$set2);
And
Intersection
    $vec3->And($vec1,$vec2);
    $set3->Intersection($set1,$set2);
AndNot
Difference
    $vec3->AndNot($vec1,$vec2);
    $set3->Difference($set1,$set2);
Xor
ExclusiveOr
    $vec3->Xor($vec1,$vec2);
    $set3->ExclusiveOr($set1,$set2);
Not
Complement
    $vec2->Not($vec1);
    $set2->Complement($set1);
subset
    if ($set1->subset($set2))  #  true if $set1 is subset of $set2
Norm
    $norm = $set->Norm();
    $norm = $set->Norm2();
    $norm = $set->Norm3();
Min
    $min = $set->Min();
Max
    $max = $set->Max();
Multiplication
    $matrix3->Multiplication($rows3,$cols3,
                    $matrix1,$rows1,$cols1,
                    $matrix2,$rows2,$cols2);
Product
    $matrix3->Product($rows3,$cols3,
             $matrix1,$rows1,$cols1,
             $matrix2,$rows2,$cols2);
Closure
    $matrix->Closure($rows,$cols);
Transpose
    $matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1);

IMPORTANT NOTES

DESCRIPTION

OVERLOADED OPERATORS

See Bit::Vector::Overload(3).

MORE STRING IMPORT/EXPORT

See Bit::Vector::String(3).

CLASS METHODS

OBJECT METHODS

SEE ALSO

Bit::Vector::Overload(3), Bit::Vector::String(3), Storable(3).

Set::IntRange(3), Math::MatrixBool(3), Math::MatrixReal(3), DFA::Kleene(3), Math::Kleene(3), Graph::Kruskal(3).

VERSION

This man page documents "Bit::Vector" version 7.4.

AUTHOR

Steffen Beyer
mailto:STBEY@cpan.org
http://www.engelschall.com/u/sb/download/

COPYRIGHT

Copyright (c) 1995 - 2013 by Steffen Beyer. All rights reserved.

LICENSE

This package is free software; you can redistribute it and/or modify it under the same terms as Perl itself, i.e., under the terms of the "Artistic License" or the "GNU General Public License".

The C library at the core of this Perl module can additionally be redistributed and/or modified under the terms of the "GNU Library General Public License".

Please refer to the files "Artistic.txt", "GNU_GPL.txt" and "GNU_LGPL.txt" in this distribution for details!

DISCLAIMER

This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the "GNU General Public License" for more details.